Enhance Request Feature

apps/db/supabase/migrations/20250620133223_new_migration.sql

@@ -0,0 +1,9 @@
+create type "public"."FEATURE_FLAG" as enum ('ENABLE_AI', 'ENABLE_EDUCATION', 'ENABLE_CHALLENGES', 'ENABLE_QUIZZES');
+
+drop index if exists "public"."workspace_education_access_requests_unique_pending";
+
+alter table "public"."workspace_education_access_requests" add column "feature" "FEATURE_FLAG" not null default 'ENABLE_EDUCATION'::"FEATURE_FLAG";
+
+CREATE UNIQUE INDEX workspace_education_access_requests_unique_pending ON public.workspace_education_access_requests USING btree (ws_id, feature) WHERE (status = 'pending'::text);
+
+

apps/upskii/src/app/[locale]/(dashboard)/[wsId]/(workspace-settings)/settings/page.tsx

@@ -8,6 +8,7 @@
 import { Plus, UserPlus } from '@tuturuuu/ui/icons';
 import { Separator } from '@tuturuuu/ui/separator';
 import { ROOT_WORKSPACE_ID } from '@tuturuuu/utils/constants';
+import { getFeatureFlags } from '@tuturuuu/utils/feature-flags/core';
 import {
   getPermissions,
   getSecrets,
@@ -35,6 +36,12 @@
   const secrets = await getSecrets({ wsId });
   const disableInvite = await verifyHasSecrets(wsId, ['DISABLE_INVITE']);
 
+  // Get feature flags for the dialog
+  const featureFlags = await getFeatureFlags(wsId, true);
+
+  // Debug logging
+  console.log('Server - Feature flags for wsId:', wsId, featureFlags);
+
   const preventWorkspaceDeletion =
     secrets
       .find((s) => s.name === 'PREVENT_WORKSPACE_DELETION')
@@ -105,7 +112,16 @@
             title={t('ws-settings.features')}
             description={t('ws-settings.features_description')}
             action={
-              <RequestFeatureAccessDialog wsId={wsId} workspaceName={ws?.name}>
+              <RequestFeatureAccessDialog
+                wsId={wsId}
+                workspaceName={ws?.name}
+                enabledFeatures={{
+                  ENABLE_AI: featureFlags.ENABLE_AI,
+                  ENABLE_EDUCATION: featureFlags.ENABLE_EDUCATION,
+                  ENABLE_QUIZZES: featureFlags.ENABLE_QUIZZES,
+                  ENABLE_CHALLENGES: featureFlags.ENABLE_CHALLENGES,
+                }}
+              >
                 <Button variant="default" size="default">
                   <Plus className="mr-2 h-4 w-4" />
                   Request Features

apps/upskii/src/app/api/v1/workspaces/[wsId]/education-access-request/route.ts

@@ -1,4 +1,5 @@
 import { createClient } from '@tuturuuu/supabase/next/server';
+import { FEATURE_FLAGS } from '@tuturuuu/utils/feature-flags/data';
 import { NextRequest, NextResponse } from 'next/server';
 
 interface Params {
@@ -7,6 +8,27 @@
   }>;
 }
 
+const FEATURE_MAP = {
+  ai: {
+    flag: FEATURE_FLAGS.ENABLE_AI,
+    name: 'AI',
+  },
+  education: {
+    flag: FEATURE_FLAGS.ENABLE_EDUCATION,
+    name: 'Education',
+  },
+  challenges: {
+    flag: FEATURE_FLAGS.ENABLE_CHALLENGES,
+    name: 'Challenges',
+  },
+  quizzes: {
+    flag: FEATURE_FLAGS.ENABLE_QUIZZES,
+    name: 'Quizzes',
+  },
+} as const;
+
+type FeatureType = keyof typeof FEATURE_MAP;
+
 export async function POST(req: NextRequest, { params }: Params) {
   try {
     const supabase = await createClient();
@@ -24,16 +46,26 @@
 
     // Parse request body
     const body = await req.json();
-    const { workspaceName, message } = body;
+    const { workspaceName, message, feature } = body;
 
     // Validate required fields
-    if (!workspaceName?.trim() || !message?.trim()) {
+    if (!workspaceName?.trim() || !message?.trim() || !feature) {
       return NextResponse.json(
-        { error: 'Workspace name and message are required' },
+        { error: 'Workspace name, message, and feature are required' },
         { status: 400 }
       );
     }
 
+    // Validate feature type
+    if (!FEATURE_MAP[feature as FeatureType]) {
+      return NextResponse.json(
+        { error: 'Invalid feature type' },
+        { status: 400 }
+      );
+    }
+
+    const featureConfig = FEATURE_MAP[feature as FeatureType];
+
     // Verify user is workspace owner
     const { data: memberCheck, error: memberError } = await supabase
       .from('workspace_members')
@@ -51,52 +83,57 @@
 
     if (memberCheck.role !== 'OWNER') {
       return NextResponse.json(
-        { error: 'Only workspace owners can request education access' },
+        {
+          error: `Only workspace owners can request ${featureConfig.name} access`,
+        },
         { status: 403 }
       );
     }
 
-    // Check if education is already enabled
-    const { data: educationSecret } = await supabase
+    // Check if feature is already enabled
+    const { data: featureSecret } = await supabase
       .from('workspace_secrets')
       .select('value')
       .eq('ws_id', wsId)
-      .eq('name', 'ENABLE_EDUCATION')
+      .eq('name', featureConfig.flag)
       .single();
 
-    if (educationSecret?.value === 'true') {
+    if (featureSecret?.value === 'true') {
       return NextResponse.json(
-        { error: 'Education features are already enabled for this workspace' },
+        {
+          error: `${featureConfig.name} features are already enabled for this workspace`,
+        },
         { status: 400 }
       );
     }
 
-    // Check for existing pending request
+    // Check for existing pending request for this feature
     const { data: existingRequest, error: existingError } = await supabase
       .from('workspace_education_access_requests')
       .select('id, status')
       .eq('ws_id', wsId)
+      .eq('feature', featureConfig.flag)
       .eq('status', 'pending')
       .single();
 
     if (existingRequest && !existingError) {
       return NextResponse.json(
         {
-          error:
-            'A pending education access request already exists for this workspace',
+          error: `A pending ${featureConfig.name} access request already exists for this workspace`,
         },
         { status: 400 }
       );
     }
 
-    // Create the education access request
+    // Create the feature access request
     const { data: newRequest, error: insertError } = await supabase
       .from('workspace_education_access_requests')
       .insert({
         ws_id: wsId,
         workspace_name: workspaceName.trim(),
         creator_id: user.id,
         message: message.trim(),
+        feature: featureConfig.flag,
         status: 'pending',
       })
       .select('*')
@@ -105,14 +142,14 @@
     if (insertError) {
       console.error('Database error:', insertError);
       return NextResponse.json(
-        { error: 'Failed to create education access request' },
+        { error: `Failed to create ${featureConfig.name} access request` },
         { status: 500 }
       );
     }
 
     return NextResponse.json(
       {
-        message: 'Education access request submitted successfully',
+        message: `${featureConfig.name} access request submitted successfully`,
         request: newRequest,
       },
       { status: 201 }
@@ -156,29 +193,22 @@
       );
     }
 
-    // Get education access request for this workspace
-    const { data: request, error: requestError } = await supabase
+    // Get all feature access requests for this workspace
+    const { data: requests, error: requestError } = await supabase
       .from('workspace_education_access_requests')
       .select('*')
       .eq('ws_id', wsId)
-      .order('created_at', { ascending: false })
-      .limit(1)
-      .single();
+      .order('created_at', { ascending: false });
 
     if (requestError) {
-      // If no request found, return null
-      if (requestError.code === 'PGRST116') {
-        return NextResponse.json({ request: null });
-      }
-
       console.error('Database error:', requestError);
       return NextResponse.json(
-        { error: 'Failed to fetch education access request' },
+        { error: 'Failed to fetch feature access requests' },
         { status: 500 }
       );
     }
 
-    return NextResponse.json({ request });
+    return NextResponse.json({ requests: requests || [] });
   } catch (error) {
     console.error('Unexpected error:', error);
     return NextResponse.json(

apps/upskii/src/components/request-feature-access-dialog.tsx

@@ -38,6 +38,12 @@
   workspaceName: string | null;
   wsId: string;
   children: React.ReactNode;
+  enabledFeatures?: {
+    ENABLE_AI: boolean;
+    ENABLE_EDUCATION: boolean;
+    ENABLE_QUIZZES: boolean;
+    ENABLE_CHALLENGES: boolean;
+  };
 }
 
 interface FeatureAccessRequest {
@@ -99,6 +105,12 @@
   workspaceName,
   wsId,
   children,
+  enabledFeatures = {
+    ENABLE_AI: false,
+    ENABLE_EDUCATION: false,
+    ENABLE_QUIZZES: false,
+    ENABLE_CHALLENGES: false,
+  },
 }: RequestFeatureAccessDialogProps) {
   const t = useTranslations('ws-settings.feature-request');
 
@@ -119,10 +131,32 @@
         .filter((r) => r.status === 'pending' || r.status === 'approved')
         .map((r) => r.feature)
     );
-    return Object.keys(featureConfig).filter(
-      (f) => !requestedOrApprovedFeatures.has(f)
+
+    // Also exclude features that are already enabled
+    const enabledFeaturesSet = new Set();
+    if (enabledFeatures?.ENABLE_AI) enabledFeaturesSet.add('ai');
+    if (enabledFeatures?.ENABLE_EDUCATION) enabledFeaturesSet.add('education');
+    if (enabledFeatures?.ENABLE_QUIZZES) enabledFeaturesSet.add('quizzes');
+    if (enabledFeatures?.ENABLE_CHALLENGES)
+      enabledFeaturesSet.add('challenges');
+
+    // Debug logging
+    console.log('Debug - enabledFeatures:', enabledFeatures);
+    console.log('Debug - enabledFeaturesSet:', enabledFeaturesSet);
+    console.log(
+      'Debug - requestedOrApprovedFeatures:',
+      requestedOrApprovedFeatures
+    );
+    console.log('Debug - all feature keys:', Object.keys(featureConfig));
+
+    const available = Object.keys(featureConfig).filter(
+      (f) => !requestedOrApprovedFeatures.has(f) && !enabledFeaturesSet.has(f)
     ) as FeatureKey[];
-  }, [existingRequests]);
+
+    console.log('Debug - availableFeatures:', available);
+
+    return available;
+  }, [existingRequests, enabledFeatures]);
 
   useEffect(() => {
     const firstFeature = availableFeatures[0];
@@ -174,7 +208,7 @@
     setIsLoading(true);
     try {
       const response = await fetch(
-        `/api/v1/workspaces/${wsId}/feature-access-requests`,
+        `/api/v1/workspaces/${wsId}/education-access-request`,
         {
           method: 'POST',
           headers: {
@@ -195,6 +229,7 @@
         await checkExistingRequests(); // Refresh requests list
         setOpen(false);
         setMessage('');
+        setSelectedFeature(null);
       } else {
         toast.error(data.error || t('toasts.error.request-failed'));
       }