@tuturuuu/utils 0.0.3 → 0.6.0

package/src/feature-flags/__tests__/feature-flags.test.ts

@@ -0,0 +1,302 @@
+import { describe, expect, it } from 'vitest';
+import { FEATURE_GROUPS } from '../core';
+import { FEATURE_FLAGS } from '../data';
+import type { FeatureFlag, FeatureFlagMap } from '../types';
+
+describe('FEATURE_FLAGS', () => {
+  describe('AI-related flags', () => {
+    it('should have ENABLE_AI flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_AI).toBe('ENABLE_AI');
+    });
+
+    it('should have ENABLE_AI_ONLY flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_AI_ONLY).toBe('ENABLE_AI_ONLY');
+    });
+
+    it('should have ENABLE_CHAT flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_CHAT).toBe('ENABLE_CHAT');
+    });
+  });
+
+  describe('Education-related flags', () => {
+    it('should have ENABLE_EDUCATION flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_EDUCATION).toBe('ENABLE_EDUCATION');
+    });
+
+    it('should have ENABLE_QUIZZES flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_QUIZZES).toBe('ENABLE_QUIZZES');
+    });
+
+    it('should have ENABLE_CHALLENGES flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_CHALLENGES).toBe('ENABLE_CHALLENGES');
+    });
+  });
+
+  describe('Document-related flags', () => {
+    it('should have ENABLE_DOCS flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_DOCS).toBe('ENABLE_DOCS');
+    });
+
+    it('should have ENABLE_DRIVE flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_DRIVE).toBe('ENABLE_DRIVE');
+    });
+
+    it('should have ENABLE_SLIDES flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_SLIDES).toBe('ENABLE_SLIDES');
+    });
+  });
+
+  describe('Task-related flags', () => {
+    it('should have ENABLE_TASKS flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_TASKS).toBe('ENABLE_TASKS');
+    });
+  });
+
+  describe('Workspace-related flags', () => {
+    it('should have DISABLE_INVITE flag', () => {
+      expect(FEATURE_FLAGS.DISABLE_INVITE).toBe('DISABLE_INVITE');
+    });
+
+    it('should have PREVENT_WORKSPACE_DELETION flag', () => {
+      expect(FEATURE_FLAGS.PREVENT_WORKSPACE_DELETION).toBe(
+        'PREVENT_WORKSPACE_DELETION'
+      );
+    });
+
+    it('should have ENABLE_AVATAR flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_AVATAR).toBe('ENABLE_AVATAR');
+    });
+
+    it('should have ENABLE_LOGO flag', () => {
+      expect(FEATURE_FLAGS.ENABLE_LOGO).toBe('ENABLE_LOGO');
+    });
+  });
+
+  describe('flag count and structure', () => {
+    it('should have exactly 14 feature flags', () => {
+      const flags = Object.keys(FEATURE_FLAGS);
+      expect(flags).toHaveLength(14);
+    });
+
+    it('should have all unique values', () => {
+      const values = Object.values(FEATURE_FLAGS);
+      const uniqueValues = new Set(values);
+      expect(uniqueValues.size).toBe(values.length);
+    });
+
+    it('should have keys matching values (self-referential)', () => {
+      for (const [key, value] of Object.entries(FEATURE_FLAGS)) {
+        expect(key).toBe(value);
+      }
+    });
+  });
+});
+
+describe('FEATURE_GROUPS', () => {
+  describe('AI_FEATURES group', () => {
+    it('should include ENABLE_AI, ENABLE_CHAT, ENABLE_TASKS', () => {
+      expect(FEATURE_GROUPS.AI_FEATURES).toContain(FEATURE_FLAGS.ENABLE_AI);
+      expect(FEATURE_GROUPS.AI_FEATURES).toContain(FEATURE_FLAGS.ENABLE_CHAT);
+      expect(FEATURE_GROUPS.AI_FEATURES).toContain(FEATURE_FLAGS.ENABLE_TASKS);
+    });
+
+    it('should have exactly 3 flags', () => {
+      expect(FEATURE_GROUPS.AI_FEATURES).toHaveLength(3);
+    });
+  });
+
+  describe('EDUCATION_FEATURES group', () => {
+    it('should include education-related flags', () => {
+      expect(FEATURE_GROUPS.EDUCATION_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_EDUCATION
+      );
+      expect(FEATURE_GROUPS.EDUCATION_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_QUIZZES
+      );
+      expect(FEATURE_GROUPS.EDUCATION_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_CHALLENGES
+      );
+      expect(FEATURE_GROUPS.EDUCATION_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_AI
+      );
+    });
+
+    it('should have exactly 4 flags', () => {
+      expect(FEATURE_GROUPS.EDUCATION_FEATURES).toHaveLength(4);
+    });
+  });
+
+  describe('DOCUMENT_FEATURES group', () => {
+    it('should include document-related flags', () => {
+      expect(FEATURE_GROUPS.DOCUMENT_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_DOCS
+      );
+      expect(FEATURE_GROUPS.DOCUMENT_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_DRIVE
+      );
+      expect(FEATURE_GROUPS.DOCUMENT_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_SLIDES
+      );
+    });
+
+    it('should have exactly 3 flags', () => {
+      expect(FEATURE_GROUPS.DOCUMENT_FEATURES).toHaveLength(3);
+    });
+  });
+
+  describe('WORKSPACE_FEATURES group', () => {
+    it('should include workspace customization flags', () => {
+      expect(FEATURE_GROUPS.WORKSPACE_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_AVATAR
+      );
+      expect(FEATURE_GROUPS.WORKSPACE_FEATURES).toContain(
+        FEATURE_FLAGS.ENABLE_LOGO
+      );
+    });
+
+    it('should have exactly 2 flags', () => {
+      expect(FEATURE_GROUPS.WORKSPACE_FEATURES).toHaveLength(2);
+    });
+  });
+
+  describe('group integrity', () => {
+    it('all groups should only contain valid feature flags', () => {
+      const allFlags = Object.values(FEATURE_FLAGS);
+
+      for (const [, group] of Object.entries(FEATURE_GROUPS)) {
+        for (const flag of group) {
+          expect(allFlags).toContain(flag);
+        }
+      }
+    });
+  });
+});
+
+describe('FeatureFlag type', () => {
+  it('should accept valid feature flag keys', () => {
+    // Type checking tests
+    const flag1: FeatureFlag = 'ENABLE_AI';
+    const flag2: FeatureFlag = 'ENABLE_EDUCATION';
+    const flag3: FeatureFlag = 'ENABLE_DOCS';
+
+    expect(flag1).toBe('ENABLE_AI');
+    expect(flag2).toBe('ENABLE_EDUCATION');
+    expect(flag3).toBe('ENABLE_DOCS');
+  });
+});
+
+describe('FeatureFlagMap type', () => {
+  it('should create valid feature flag map', () => {
+    const flagMap: FeatureFlagMap = {
+      ENABLE_AI: true,
+      ENABLE_EDUCATION: false,
+      ENABLE_QUIZZES: true,
+      ENABLE_CHALLENGES: false,
+      ENABLE_AI_ONLY: false,
+      ENABLE_CHAT: true,
+      ENABLE_TASKS: true,
+      ENABLE_DOCS: false,
+      ENABLE_DRIVE: false,
+      ENABLE_SLIDES: false,
+      DISABLE_INVITE: false,
+      PREVENT_WORKSPACE_DELETION: true,
+      ENABLE_AVATAR: true,
+      ENABLE_LOGO: true,
+    };
+
+    expect(flagMap.ENABLE_AI).toBe(true);
+    expect(flagMap.ENABLE_EDUCATION).toBe(false);
+  });
+
+  it('should enforce boolean values', () => {
+    const flagMap: Partial<FeatureFlagMap> = {
+      ENABLE_AI: true,
+      ENABLE_EDUCATION: false,
+    };
+
+    expect(typeof flagMap.ENABLE_AI).toBe('boolean');
+    expect(typeof flagMap.ENABLE_EDUCATION).toBe('boolean');
+  });
+});
+
+describe('Feature flag usage patterns', () => {
+  describe('checking multiple flags', () => {
+    it('should support checking if all flags are enabled', () => {
+      const flagMap: FeatureFlagMap = {
+        ENABLE_AI: true,
+        ENABLE_EDUCATION: true,
+        ENABLE_QUIZZES: true,
+        ENABLE_CHALLENGES: true,
+        ENABLE_AI_ONLY: false,
+        ENABLE_CHAT: true,
+        ENABLE_TASKS: true,
+        ENABLE_DOCS: true,
+        ENABLE_DRIVE: true,
+        ENABLE_SLIDES: true,
+        DISABLE_INVITE: false,
+        PREVENT_WORKSPACE_DELETION: false,
+        ENABLE_AVATAR: true,
+        ENABLE_LOGO: true,
+      };
+
+      const aiFeatures: FeatureFlag[] = [
+        'ENABLE_AI',
+        'ENABLE_CHAT',
+        'ENABLE_TASKS',
+      ];
+      const allAIEnabled = aiFeatures.every((flag) => flagMap[flag]);
+      expect(allAIEnabled).toBe(true);
+    });
+
+    it('should support checking if any flag is enabled', () => {
+      const flagMap: FeatureFlagMap = {
+        ENABLE_AI: false,
+        ENABLE_EDUCATION: false,
+        ENABLE_QUIZZES: false,
+        ENABLE_CHALLENGES: true, // Only this is enabled
+        ENABLE_AI_ONLY: false,
+        ENABLE_CHAT: false,
+        ENABLE_TASKS: false,
+        ENABLE_DOCS: false,
+        ENABLE_DRIVE: false,
+        ENABLE_SLIDES: false,
+        DISABLE_INVITE: false,
+        PREVENT_WORKSPACE_DELETION: false,
+        ENABLE_AVATAR: false,
+        ENABLE_LOGO: false,
+      };
+
+      const educationFeatures: FeatureFlag[] = [
+        'ENABLE_EDUCATION',
+        'ENABLE_QUIZZES',
+        'ENABLE_CHALLENGES',
+      ];
+      const anyEducationEnabled = educationFeatures.some(
+        (flag) => flagMap[flag]
+      );
+      expect(anyEducationEnabled).toBe(true);
+    });
+  });
+
+  describe('negative flags (DISABLE_*)', () => {
+    it('should handle DISABLE_INVITE flag logic', () => {
+      const flagMap: Partial<FeatureFlagMap> = {
+        DISABLE_INVITE: true,
+      };
+
+      // When DISABLE_INVITE is true, invites should be disabled
+      const invitesEnabled = !flagMap.DISABLE_INVITE;
+      expect(invitesEnabled).toBe(false);
+    });
+
+    it('should handle PREVENT_WORKSPACE_DELETION flag logic', () => {
+      const flagMap: Partial<FeatureFlagMap> = {
+        PREVENT_WORKSPACE_DELETION: true,
+      };
+
+      // When PREVENT_WORKSPACE_DELETION is true, deletion should be prevented
+      const canDelete = !flagMap.PREVENT_WORKSPACE_DELETION;
+      expect(canDelete).toBe(false);
+    });
+  });
+});

package/src/feature-flags/core.ts

@@ -0,0 +1,322 @@
+import { verifySecret } from '../workspace-helper';
+import { FEATURE_FLAGS } from './data';
+import type { FeatureFlag, FeatureFlagMap } from './types';
+
+export async function requireFeatureFlags(
+  wsId: string,
+  {
+    requiredFlags = [],
+    forceAdmin = false,
+  }: {
+    requiredFlags: FeatureFlag[];
+    forceAdmin?: boolean;
+  }
+): Promise<{ featureFlags: FeatureFlagMap; missingFlags: FeatureFlag[] }> {
+  const featureFlags = await getFeatureFlags(wsId, forceAdmin);
+  const missingFlags = requiredFlags.filter((flag) => !featureFlags[flag]);
+  return {
+    featureFlags,
+    missingFlags,
+  };
+}
+
+/**
+ * Get all feature flags for a workspace
+ * @param wsId - Workspace ID
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<FeatureFlags>
+ */
+export async function getFeatureFlags(
+  wsId: string,
+  forceAdmin: boolean = true
+): Promise<FeatureFlagMap> {
+  const [
+    ENABLE_AI,
+    ENABLE_EDUCATION,
+    ENABLE_QUIZZES,
+    ENABLE_CHALLENGES,
+    ENABLE_AI_ONLY,
+    ENABLE_CHAT,
+    ENABLE_TASKS,
+    ENABLE_DOCS,
+    ENABLE_DRIVE,
+    ENABLE_SLIDES,
+    DISABLE_INVITE,
+    PREVENT_WORKSPACE_DELETION,
+    ENABLE_AVATAR,
+    ENABLE_LOGO,
+  ] = await Promise.all([
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_AI,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_EDUCATION,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_QUIZZES,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_CHALLENGES,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_AI_ONLY,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_CHAT,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_TASKS,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_DOCS,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_DRIVE,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_SLIDES,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.DISABLE_INVITE,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.PREVENT_WORKSPACE_DELETION,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_AVATAR,
+      value: 'true',
+    }),
+    verifySecret({
+      forceAdmin,
+      wsId,
+      name: FEATURE_FLAGS.ENABLE_LOGO,
+      value: 'true',
+    }),
+  ]);
+
+  return {
+    ENABLE_AI,
+    ENABLE_EDUCATION,
+    ENABLE_QUIZZES,
+    ENABLE_CHALLENGES,
+    ENABLE_AI_ONLY,
+    ENABLE_CHAT,
+    ENABLE_TASKS,
+    ENABLE_DOCS,
+    ENABLE_DRIVE,
+    ENABLE_SLIDES,
+    DISABLE_INVITE,
+    PREVENT_WORKSPACE_DELETION,
+    ENABLE_AVATAR,
+    ENABLE_LOGO,
+  };
+}
+
+/**
+ * Get a specific feature flag
+ * @param wsId - Workspace ID
+ * @param flagName - Feature flag name
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function getFeatureFlag(
+  wsId: string,
+  flagName: FeatureFlag,
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  return verifySecret({
+    forceAdmin,
+    wsId,
+    name: FEATURE_FLAGS[flagName],
+    value: 'true',
+  });
+}
+
+/**
+ * Check if multiple feature flags are enabled
+ * @param wsId - Workspace ID
+ * @param flagNames - Array of feature flag names
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function areFeatureFlagsEnabled(
+  wsId: string,
+  flagNames: readonly FeatureFlag[],
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  const checks = await Promise.all(
+    flagNames.map((flagName) =>
+      verifySecret({
+        forceAdmin,
+        wsId,
+        name: FEATURE_FLAGS[flagName],
+        value: 'true',
+      })
+    )
+  );
+  return checks.every(Boolean);
+}
+
+/**
+ * Check if any of the specified feature flags are enabled
+ * @param wsId - Workspace ID
+ * @param flagNames - Array of feature flag names
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function isAnyFeatureFlagEnabled(
+  wsId: string,
+  flagNames: readonly FeatureFlag[],
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  const checks = await Promise.all(
+    flagNames.map((flagName) =>
+      verifySecret({
+        forceAdmin,
+        wsId,
+        name: FEATURE_FLAGS[flagName],
+        value: 'true',
+      })
+    )
+  );
+  return checks.some(Boolean);
+}
+
+// Common feature flag combinations
+export const FEATURE_GROUPS = {
+  AI_FEATURES: [
+    FEATURE_FLAGS.ENABLE_AI,
+    FEATURE_FLAGS.ENABLE_CHAT,
+    FEATURE_FLAGS.ENABLE_TASKS,
+  ] as const,
+  EDUCATION_FEATURES: [
+    FEATURE_FLAGS.ENABLE_EDUCATION,
+    FEATURE_FLAGS.ENABLE_QUIZZES,
+    FEATURE_FLAGS.ENABLE_CHALLENGES,
+    FEATURE_FLAGS.ENABLE_AI,
+  ] as const,
+  DOCUMENT_FEATURES: [
+    FEATURE_FLAGS.ENABLE_DOCS,
+    FEATURE_FLAGS.ENABLE_DRIVE,
+    FEATURE_FLAGS.ENABLE_SLIDES,
+  ] as const,
+  WORKSPACE_FEATURES: [
+    FEATURE_FLAGS.ENABLE_AVATAR,
+    FEATURE_FLAGS.ENABLE_LOGO,
+  ] as const,
+} as const;
+
+/**
+ * Check if all AI features are enabled
+ * @param wsId - Workspace ID
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function areAIFeaturesEnabled(
+  wsId: string,
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  return areFeatureFlagsEnabled(wsId, FEATURE_GROUPS.AI_FEATURES, forceAdmin);
+}
+
+/**
+ * Check if all education features are enabled
+ * @param wsId - Workspace ID
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function areEducationFeaturesEnabled(
+  wsId: string,
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  return areFeatureFlagsEnabled(
+    wsId,
+    FEATURE_GROUPS.EDUCATION_FEATURES,
+    forceAdmin
+  );
+}
+
+/**
+ * Check if all document features are enabled
+ * @param wsId - Workspace ID
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function areDocumentFeaturesEnabled(
+  wsId: string,
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  return areFeatureFlagsEnabled(
+    wsId,
+    FEATURE_GROUPS.DOCUMENT_FEATURES,
+    forceAdmin
+  );
+}
+
+/**
+ * Check if any AI features are enabled
+ * @param wsId - Workspace ID
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function isAnyAIFeatureEnabled(
+  wsId: string,
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  return isAnyFeatureFlagEnabled(wsId, FEATURE_GROUPS.AI_FEATURES, forceAdmin);
+}
+
+/**
+ * Check if any education features are enabled
+ * @param wsId - Workspace ID
+ * @param forceAdmin - Whether to use admin client (default: true for feature flags)
+ * @returns Promise<boolean>
+ */
+export async function isAnyEducationFeatureEnabled(
+  wsId: string,
+  forceAdmin: boolean = true
+): Promise<boolean> {
+  return isAnyFeatureFlagEnabled(
+    wsId,
+    FEATURE_GROUPS.EDUCATION_FEATURES,
+    forceAdmin
+  );
+}

package/src/feature-flags/data.ts

@@ -0,0 +1,16 @@
+export const FEATURE_FLAGS = {
+  ENABLE_AI: 'ENABLE_AI',
+  ENABLE_EDUCATION: 'ENABLE_EDUCATION',
+  ENABLE_QUIZZES: 'ENABLE_QUIZZES',
+  ENABLE_CHALLENGES: 'ENABLE_CHALLENGES',
+  ENABLE_AI_ONLY: 'ENABLE_AI_ONLY',
+  ENABLE_CHAT: 'ENABLE_CHAT',
+  ENABLE_TASKS: 'ENABLE_TASKS',
+  ENABLE_DOCS: 'ENABLE_DOCS',
+  ENABLE_DRIVE: 'ENABLE_DRIVE',
+  ENABLE_SLIDES: 'ENABLE_SLIDES',
+  DISABLE_INVITE: 'DISABLE_INVITE',
+  PREVENT_WORKSPACE_DELETION: 'PREVENT_WORKSPACE_DELETION',
+  ENABLE_AVATAR: 'ENABLE_AVATAR',
+  ENABLE_LOGO: 'ENABLE_LOGO',
+} as const;

package/src/feature-flags/default.ts

@@ -0,0 +1,18 @@
+import type { FeatureFlagMap } from './types';
+
+export const DEFAULT_FEATURE_FLAGS: FeatureFlagMap = {
+  ENABLE_AI: false,
+  ENABLE_EDUCATION: false,
+  ENABLE_QUIZZES: false,
+  ENABLE_CHALLENGES: false,
+  ENABLE_AI_ONLY: false,
+  ENABLE_CHAT: false,
+  ENABLE_TASKS: false,
+  ENABLE_DOCS: false,
+  ENABLE_DRIVE: false,
+  ENABLE_SLIDES: false,
+  DISABLE_INVITE: false,
+  PREVENT_WORKSPACE_DELETION: false,
+  ENABLE_AVATAR: false,
+  ENABLE_LOGO: false,
+};

package/src/feature-flags/index.ts

@@ -0,0 +1,7 @@
+// Core feature flags
+export * from './core';
+export * from './data';
+export * from './default';
+// Requestable features
+export * from './requestable-features';
+export * from './types';