@plyaz/core 1.1.0 → 1.2.0

package/dist/backend/featureFlags/database/repository.d.ts

@@ -0,0 +1,518 @@
+/**
+ * Database Repository Implementation
+ *
+ * Database adapter integration with @plyaz/db for feature flag storage.
+ * Provides optimized queries and transaction management.
+ *
+ * @fileoverview Database repository for feature flags
+ */
+import { type FeatureFlag, type FeatureFlagRule, type FeatureFlagValue, type CreateFlagRequest, type FeatureFlagContext } from '@plyaz/types';
+import type { FeatureFlagKey } from '@domain/types';
+/**
+ * Database Repository for Feature Flags
+ *
+ * **FOURTH COMPONENT CALLED** - Handles all database operations for feature flags
+ *
+ * **EXECUTION ORDER:**
+ * 1. FeatureFlagService.onModuleInit()
+ * 2. → FeatureFlagConfigFactory.fromEnvironment()
+ * 3. → DatabaseConnectionManager.initialize()
+ * 4. → **THIS REPOSITORY USED** ← YOU ARE HERE
+ * 5. → Database queries executed via Drizzle ORM
+ *
+ * **PURPOSE:**
+ * - Executes optimized SQL queries using Drizzle ORM
+ * - Maps database rows to TypeScript types
+ * - Handles CRUD operations for flags, rules, evaluations, and overrides
+ * - Provides audit logging and user override functionality
+ *
+ * **PERFORMANCE FEATURES:**
+ * - Uses database indexes for fast queries
+ * - Batch operations where possible
+ * - Connection pooling via DatabaseConnectionManager
+ * - Optimized queries with proper WHERE clauses and ordering
+ *
+ * @template TKey - Feature flag key type (extends string)
+ *
+ * @example Basic Usage (automatically called by provider):
+ * ```typescript
+ * const repository = new FeatureFlagDatabaseRepository();
+ *
+ * // Get all flags (called during system initialization)
+ * const flags = await repository.getAllFlags();
+ *
+ * // Get specific flag (called during runtime evaluation)
+ * const flag = await repository.getFlag('PREMIUM_FEATURE');
+ *
+ * // Create new flag (called via admin API)
+ * const newFlag = await repository.createFlag({
+ *   key: 'NEW_FEATURE',
+ *   value: true,
+ *   isEnabled: true,
+ *   description: 'New awesome feature'
+ * });
+ * ```
+ *
+ * @example Query Performance:
+ * ```sql
+ * -- Optimized queries with indexes:
+ * SELECT * FROM feature_flags WHERE key = 'PREMIUM_FEATURE';  -- Uses primary key index
+ * SELECT * FROM feature_flag_rules WHERE flag_key = 'PREMIUM_FEATURE' AND is_enabled = true ORDER BY priority DESC;  -- Uses composite index
+ * ```
+ */
+export declare class FeatureFlagDatabaseRepository<TKey extends string = FeatureFlagKey> {
+    private connectionManager;
+    /**
+     * Retrieves all feature flags from the database with optional environment filtering
+     *
+     * @description Fetches all feature flags from the database. This method is primarily called
+     * during system initialization to load flags into cache, but can also be used for
+     * administrative purposes or cache refresh operations.
+     *
+     * @param {string} [environment] - Optional environment filter (e.g., 'production', 'staging')
+     * @returns {Promise<FeatureFlag<TKey>[]>} Array of feature flags matching the criteria
+     *
+     * @throws {Error} When database query fails critically
+     *
+     * @example
+     * ```typescript
+     * // Get all flags for system initialization
+     * const repository = new FeatureFlagDatabaseRepository();
+     * const allFlags = await repository.getAllFlags();
+     * console.log(`Loaded ${allFlags.length} feature flags`);
+     *
+     * // Get only production flags
+     * const prodFlags = await repository.getAllFlags('production');
+     * console.log(`Production flags: ${prodFlags.length}`);
+     *
+     * // Handle empty results
+     * const flags = await repository.getAllFlags('nonexistent');
+     * if (flags.length === 0) {
+     *   console.log('No flags found for environment');
+     * }
+     * ```
+     *
+     */
+    getAllFlags(environment?: string): Promise<FeatureFlag<TKey>[]>;
+    /**
+     * Retrieves a specific feature flag by its key
+     *
+     * @description Fetches a single feature flag from the database using its unique key.
+     * This method is optimized for runtime flag evaluation and uses the primary key index
+     * for O(1) lookup performance.
+     *
+     * @param {TKey} key - The unique identifier of the feature flag to retrieve
+     * @returns {Promise<FeatureFlag<TKey> | null>} The feature flag object or null if not found
+     *
+     * @throws {Error} When database operation fails
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Get a specific flag for evaluation
+     * const premiumFlag = await repository.getFlag('PREMIUM_FEATURE');
+     * if (premiumFlag) {
+     *   console.log(`Flag enabled: ${premiumFlag.isEnabled}`);
+     *   console.log(`Flag value:`, premiumFlag.value);
+     * } else {
+     *   console.log('Flag not found');
+     * }
+     *
+     * // Handle flag evaluation
+     * const checkoutFlag = await repository.getFlag('NEW_CHECKOUT');
+     * const isNewCheckoutEnabled = checkoutFlag?.isEnabled ?? false;
+     * ```
+     *
+     */
+    getFlag(key: TKey): Promise<FeatureFlag<TKey> | null>;
+    /**
+     * Creates a new feature flag in the database
+     *
+     * @description Creates a new feature flag record with the provided configuration.
+     * This method is typically called through administrative interfaces or during
+     * system setup and migration processes.
+     *
+     * @param {CreateFlagRequest<TKey>} data - The feature flag creation data
+     * @returns {Promise<FeatureFlag<TKey>>} The created feature flag object
+     *
+     * @throws {Error} When flag key already exists (primary key constraint violation)
+     * @throws {Error} When database operation fails
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Create a simple boolean flag
+     * const simpleFlag = await repository.createFlag({
+     *   key: 'ENABLE_DARK_MODE',
+     *   value: true,
+     *   isEnabled: true,
+     *   environment: 'production',
+     *   description: 'Enable dark mode theme'
+     * });
+     *
+     * // Create a complex flag with object value
+     * const complexFlag = await repository.createFlag({
+     *   key: 'CHECKOUT_CONFIG',
+     *   value: {
+     *     variant: 'blue',
+     *     showPromo: true,
+     *     maxItems: 10
+     *   },
+     *   isEnabled: false,
+     *   environment: 'staging',
+     *   description: 'Checkout page configuration'
+     * });
+     *
+     * console.log(`Created flag: ${simpleFlag.key}`);
+     * ```
+     *
+     */
+    createFlag(data: CreateFlagRequest<TKey>): Promise<FeatureFlag<TKey>>;
+    /**
+     * Updates an existing feature flag in the database
+     *
+     * @description Updates specific fields of an existing feature flag. Only provided
+     * fields will be updated, leaving other fields unchanged. The updated_at timestamp
+     * is automatically set to the current time.
+     *
+     * @param {TKey} key - The unique identifier of the feature flag to update
+     * @param {Partial<CreateFlagRequest<TKey>>} data - Partial flag data to update
+     * @returns {Promise<FeatureFlag<TKey>>} The updated feature flag object
+     *
+     * @throws {Error} When flag with the specified key is not found
+     * @throws {Error} When database operation fails
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Enable a flag
+     * const enabledFlag = await repository.updateFlag('BETA_FEATURE', {
+     *   isEnabled: true
+     * });
+     *
+     * // Update flag value and description
+     * const updatedFlag = await repository.updateFlag('CHECKOUT_CONFIG', {
+     *   value: { variant: 'green', showPromo: false },
+     *   description: 'Updated checkout configuration'
+     * });
+     *
+     * // Change environment
+     * const prodFlag = await repository.updateFlag('NEW_FEATURE', {
+     *   environment: 'production'
+     * });
+     *
+     * console.log(`Updated flag: ${updatedFlag.key}`);
+     * ```
+     *
+     */
+    updateFlag(key: TKey, data: Partial<CreateFlagRequest<TKey>>): Promise<FeatureFlag<TKey>>;
+    /**
+     * Deletes a feature flag from the database
+     *
+     * @description Permanently removes a feature flag from the database. This operation
+     * cannot be undone. All associated rules, evaluations, and overrides should be
+     * cleaned up separately if needed.
+     *
+     * @param {TKey} key - The unique identifier of the feature flag to delete
+     * @returns {Promise<void>} Promise that resolves when deletion is complete
+     *
+     * @throws {Error} When flag with the specified key is not found
+     * @throws {Error} When database operation fails
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Delete a flag
+     * try {
+     *   await repository.deleteFlag('OLD_FEATURE');
+     *   console.log('Flag deleted successfully');
+     * } catch (error) {
+     *   console.error('Failed to delete flag:', error.message);
+     * }
+     *
+     * // Verify deletion
+     * const deletedFlag = await repository.getFlag('OLD_FEATURE');
+     * console.log(deletedFlag === null); // true
+     * ```
+     *
+     */
+    deleteFlag(key: TKey): Promise<void>;
+    /**
+     * Retrieves all rules associated with a specific feature flag
+     *
+     * @description Fetches all rules configured for a specific feature flag, ordered by
+     * priority in descending order. Rules are used for advanced flag evaluation logic
+     * based on user context and conditions.
+     *
+     * @param {TKey} key - The feature flag key to get rules for
+     * @returns {Promise<FeatureFlagRule<TKey>[]>} Array of rules for the specified flag
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Get rules for a flag
+     * const rules = await repository.getFlagRules('PREMIUM_FEATURE');
+     * console.log(`Found ${rules.length} rules`);
+     *
+     * // Process rules by priority
+     * rules.forEach(rule => {
+     *   console.log(`Rule: ${rule.name}, Priority: ${rule.priority}`);
+     * });
+     * ```
+     *
+     */
+    getFlagRules(key: TKey): Promise<FeatureFlagRule<TKey>[]>;
+    /**
+     * Retrieves all enabled feature flag rules from the database
+     *
+     * @description Fetches all enabled rules across all feature flags, sorted by flag key
+     * and then by priority. This method is used during system initialization to load
+     * all active rules into the evaluation engine.
+     *
+     * @returns {Promise<FeatureFlagRule<TKey>[]>} Array of all enabled rules
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Load all rules for evaluation engine
+     * const allRules = await repository.getAllRules();
+     * console.log(`Loaded ${allRules.length} active rules`);
+     *
+     * // Group rules by flag
+     * const rulesByFlag = allRules.reduce((acc, rule) => {
+     *   if (!acc[rule.flagKey]) acc[rule.flagKey] = [];
+     *   acc[rule.flagKey].push(rule);
+     *   return acc;
+     * }, {});
+     * ```
+     *
+     */
+    getAllRules(): Promise<FeatureFlagRule<TKey>[]>;
+    /**
+     * Logs a feature flag evaluation for audit and analytics purposes
+     *
+     * @description Records feature flag evaluation events for compliance tracking,
+     * debugging, and analytics. This method is called after each flag evaluation
+     * when audit logging is enabled.
+     *
+     * @param {Object} params - The evaluation parameters
+     * @param {TKey} params.flagKey - The feature flag key that was evaluated
+     * @param {string} [params.userId] - Optional user ID who triggered the evaluation
+     * @param {FeatureFlagContext} [params.context] - Optional evaluation context
+     * @param {FeatureFlagValue} params.result - The evaluation result
+     * @returns {Promise<void>} Promise that resolves when log entry is created
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Log a user evaluation
+     * await repository.logEvaluation({
+     *   flagKey: 'PREMIUM_FEATURE',
+     *   userId: 'user123',
+     *   context: {
+     *     userRole: 'premium',
+     *     environment: 'production',
+     *     requestId: 'req-456'
+     *   },
+     *   result: true
+     * });
+     *
+     * // Log anonymous evaluation
+     * await repository.logEvaluation({
+     *   flagKey: 'PUBLIC_FEATURE',
+     *   result: { variant: 'blue', enabled: true }
+     * });
+     * ```
+     *
+     */
+    logEvaluation(params: {
+        flagKey: TKey;
+        userId?: string;
+        context?: FeatureFlagContext;
+        result: FeatureFlagValue;
+    }): Promise<void>;
+    /**
+     * Sets a user-specific override for a feature flag
+     *
+     * @description Creates a user-specific override that takes precedence over the
+     * default flag value and rules. Overrides can have optional expiration times
+     * and are useful for testing, gradual rollouts, or user-specific configurations.
+     *
+     * @param {TKey} flagKey - The feature flag key to override
+     * @param {string} userId - The user ID for whom to set the override
+     * @param {FeatureFlagValue} value - The override value
+     * @param {Date} [expiresAt] - Optional expiration date for the override
+     * @returns {Promise<void>} Promise that resolves when override is created
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Set permanent override
+     * await repository.setOverride(
+     *   'BETA_FEATURE',
+     *   'user123',
+     *   true
+     * );
+     *
+     * // Set temporary override (expires in 1 hour)
+     * const expiresAt = new Date(Date.now() + 60 * 60 * 1000);
+     * await repository.setOverride(
+     *   'PREMIUM_FEATURE',
+     *   'testuser456',
+     *   { enabled: true, variant: 'premium' },
+     *   expiresAt
+     * );
+     * ```
+     *
+     */
+    setOverride(flagKey: TKey, userId: string, value: FeatureFlagValue, expiresAt?: Date): Promise<void>;
+    /**
+     * Retrieves a user-specific override for a feature flag
+     *
+     * @description Fetches the override value for a specific user and flag combination.
+     * Automatically filters out expired overrides. Returns null if no valid override
+     * exists for the user.
+     *
+     * @param {TKey} flagKey - The feature flag key to check for overrides
+     * @param {string} userId - The user ID to get the override for
+     * @returns {Promise<FeatureFlagValue | null>} The override value or null if none exists
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Check for user override
+     * const override = await repository.getOverride('BETA_FEATURE', 'user123');
+     * if (override !== null) {
+     *   console.log('User has override:', override);
+     * } else {
+     *   console.log('No override found, using default flag value');
+     * }
+     *
+     * // Use in flag evaluation
+     * const userOverride = await repository.getOverride('PREMIUM_FEATURE', userId);
+     * const flagValue = userOverride ?? defaultFlagValue;
+     * ```
+     *
+     */
+    getOverride(flagKey: TKey, userId: string): Promise<FeatureFlagValue | null>;
+    /**
+     * Removes user-specific overrides for a feature flag
+     *
+     * @description Deletes all override records for a specific user and flag combination.
+     * This operation cannot be undone and will cause the user to receive the default
+     * flag value or rule-based evaluation on subsequent requests.
+     *
+     * @param {TKey} flagKey - The feature flag key to remove overrides for
+     * @param {string} userId - The user ID to remove overrides for
+     * @returns {Promise<void>} Promise that resolves when overrides are removed
+     *
+     * @example
+     * ```typescript
+     * const repository = new FeatureFlagDatabaseRepository();
+     *
+     * // Remove user override
+     * await repository.removeOverride('BETA_FEATURE', 'user123');
+     * console.log('Override removed, user will get default flag value');
+     *
+     * // Verify removal
+     * const override = await repository.getOverride('BETA_FEATURE', 'user123');
+     * console.log(override === null); // true
+     *
+     * // Bulk cleanup - remove overrides for multiple users
+     * const userIds = ['user1', 'user2', 'user3'];
+     * for (const userId of userIds) {
+     *   await repository.removeOverride('OLD_FEATURE', userId);
+     * }
+     * ```
+     *
+     */
+    removeOverride(flagKey: TKey, userId: string): Promise<void>;
+    /**
+     * Maps a database row to a FeatureFlag object
+     *
+     * @description Converts raw database row data to a properly typed FeatureFlag object.
+     * Handles field name variations between database schema and application types,
+     * provides default values for missing fields, and ensures type safety.
+     *
+     * @private
+     * @param {DatabaseFeatureFlagRow} row - Raw database row data
+     * @returns {FeatureFlag<TKey>} Typed FeatureFlag object
+     *
+     * @example
+     * ```typescript
+     * // Database row input:
+     * const dbRow = {
+     *   key: 'PREMIUM_FEATURE',
+     *   value: { enabled: true, variant: 'blue' },
+     *   is_enabled: true,
+     *   environments: ['production'],
+     *   description: 'Premium feature toggle',
+     *   created_at: '2024-01-15T10:30:00Z'
+     * };
+     *
+     * // Mapped output:
+     * const flag = this.mapToFeatureFlag(dbRow);
+     * // {
+     * //   key: 'PREMIUM_FEATURE',
+     * //   type: 'boolean',
+     * //   name: 'PREMIUM_FEATURE',
+     * //   value: { enabled: true, variant: 'blue' },
+     * //   isEnabled: true,
+     * //   environment: 'production',
+     * //   description: 'Premium feature toggle',
+     * //   createdAt: Date('2024-01-15T10:30:00Z'),
+     * //   updatedAt: Date('2024-01-15T10:30:00Z'),
+     * //   createdBy: 'system',
+     * //   updatedBy: 'system'
+     * // }
+     * ```
+     *
+     */
+    private mapToFeatureFlag;
+    /**
+     * Extracts the enabled status from a database row
+     *
+     * @private
+     * @param {DatabaseFeatureFlagRow} row - Database row with enabled field variations
+     * @returns {boolean} The enabled status, defaulting to true if not specified
+     */
+    private getIsEnabled;
+    /**
+     * Extracts the creation date from a database row
+     *
+     * @private
+     * @param {DatabaseFeatureFlagRow} row - Database row with creation date field variations
+     * @returns {Date} The creation date, defaulting to current date if not specified
+     */
+    private getCreatedAt;
+    /**
+     * Extracts the update date from a database row
+     *
+     * @private
+     * @param {DatabaseFeatureFlagRow} row - Database row with update date field variations
+     * @returns {Date} The update date, defaulting to current date if not specified
+     */
+    private getUpdatedAt;
+    /**
+     * Maps a database row to a FeatureFlagRule object
+     *
+     * @description Converts raw database rule row data to a properly typed FeatureFlagRule object.
+     * Handles field name variations and ensures type safety for rule evaluation.
+     *
+     * @private
+     * @param {DatabaseFeatureFlagRuleRow} row - Raw database rule row data
+     * @returns {FeatureFlagRule<TKey>} Typed FeatureFlagRule object
+     *
+     */
+    private mapToFeatureFlagRule;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/backend/featureFlags/database/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/database/repository.ts"],"names":[],"mappings":"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"}

package/dist/backend/featureFlags/decorators/feature-disabled.decorator.d.ts

@@ -0,0 +1,6 @@
+import type { FeatureFlagKey } from '@domain/types';
+/**
+ * Shortcut decorator to require a feature flag to be disabled (false).
+ */
+export declare function FeatureDisabled(key: FeatureFlagKey): MethodDecorator;
+//# sourceMappingURL=feature-disabled.decorator.d.ts.map

package/dist/backend/featureFlags/decorators/feature-disabled.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-disabled.decorator.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/decorators/feature-disabled.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG,eAAe,CAEpE"}

package/dist/backend/featureFlags/decorators/feature-enabled.decorator.d.ts

@@ -0,0 +1,8 @@
+import type { FeatureFlagKey } from '@domain/types';
+/**
+ * FeatureEnabled decorator
+ * Shorthand for enabling a feature flag with `true`
+ */
+export declare function FeatureEnabled(key: FeatureFlagKey): MethodDecorator;
+export {};
+//# sourceMappingURL=feature-enabled.decorator.d.ts.map

package/dist/backend/featureFlags/decorators/feature-enabled.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-enabled.decorator.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/decorators/feature-enabled.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,eAAe,CAEnE;AAGD,OAAO,EAAE,CAAC"}

package/dist/backend/featureFlags/decorators/feature-flag.decorator.d.ts

@@ -0,0 +1,11 @@
+import type { FeatureFlagValue } from '@plyaz/types';
+import type { FeatureFlagKey } from '@domain/types';
+/**
+ * Decorator to require a feature flag to be in a specific state
+ * before allowing access to the route handler.
+ *
+ * @param key - The feature flag key
+ * @param expected - Expected flag value (default: true)
+ */
+export declare function FeatureFlag(key: FeatureFlagKey, expected?: FeatureFlagValue): MethodDecorator;
+//# sourceMappingURL=feature-flag.decorator.d.ts.map

package/dist/backend/featureFlags/decorators/feature-flag.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.decorator.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/decorators/feature-flag.decorator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,cAAc,EACnB,QAAQ,GAAE,gBAAuB,GAChC,eAAe,CAEjB"}

package/dist/backend/featureFlags/feature-flag.controller.d.ts

@@ -5,9 +5,8 @@
  * Provides REST API endpoints for feature flag operations.
  *
  * @fileoverview NestJS controller for feature flags
- * @version 1.0.0
  */
-import type { FeatureFlagValue, FeatureFlagContext, FeatureFlagEvaluation, FeatureFlag, FeatureFlagRule } from '@plyaz/types';
+import { type FeatureFlagValue, type FeatureFlagContext, type FeatureFlagEvaluation, type FeatureFlag, type FeatureFlagRule } from '@plyaz/types';
 import type { FeatureFlagService } from './feature-flag.service';
 import type { FeatureFlagKey } from '@domain/types';
 /**

package/dist/backend/featureFlags/feature-flag.controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flag.controller.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAcH,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,eAAe,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,KAAK,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;IAC/D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBACa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE;;;;;;OAMG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;IAWjD;;;;;;OAMG;IAEG,SAAS,CACC,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAYlC;;;;;OAKG;IAEG,gBAAgB,CACZ,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC;IAWjE;;;;;;OAMG;IAEG,UAAU,CACN,UAAU,EAAE,iBAAiB,GAAG;QAAE,GAAG,EAAE,cAAc,CAAA;KAAE,GAC9D,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAWvC;;;;;;OAMG;IAEG,UAAU,CACA,GAAG,EAAE,cAAc,EACzB,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAC7C,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAWvC;;;;OAIG;IAEG,UAAU,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAYvF;;;;;OAKG;IAEG,WAAW,CACD,GAAG,EAAE,cAAc,EAClB,KAAK,EAAE,gBAAgB,GACrC,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAYrC;;;;OAIG;IAEG,cAAc,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAY3F;;;;;OAKG;IAEG,kBAAkB,CACA,WAAW,CAAC,EAAE,MAAM,GACzC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;IAWzC;;;;;OAKG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,GAChC,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,CAAC;IAW7C;;OAEG;IAEG,YAAY,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;CAWzD"}
+{"version":3,"file":"feature-flag.controller.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,eAAe,EAGrB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,KAAK,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;IAC/D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBACa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE;;;;;;OAMG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;IAYjD;;;;;;OAMG;IAEG,SAAS,CACC,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAalC;;;;;OAKG;IAEG,gBAAgB,CACZ,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC;IAYjE;;;;;;OAMG;IAEG,UAAU,CACN,UAAU,EAAE,iBAAiB,GAAG;QAAE,GAAG,EAAE,cAAc,CAAA;KAAE,GAC9D,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAYvC;;;;;;OAMG;IAEG,UAAU,CACA,GAAG,EAAE,cAAc,EACzB,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAC7C,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAYvC;;;;OAIG;IAEG,UAAU,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAavF;;;;;OAKG;IAEG,WAAW,CACD,GAAG,EAAE,cAAc,EAClB,KAAK,EAAE,gBAAgB,GACrC,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAarC;;;;OAIG;IAEG,cAAc,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAa3F;;;;;OAKG;IAEG,kBAAkB,CACA,WAAW,CAAC,EAAE,MAAM,GACzC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;IAYzC;;;;;OAKG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,GAChC,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,CAAC;IAY7C;;OAEG;IAEG,YAAY,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;CAYzD"}

package/dist/backend/featureFlags/feature-flag.module.d.ts

@@ -5,7 +5,6 @@
  * Configures providers, controllers, and dependencies.
  *
  * @fileoverview NestJS module for feature flags
- * @version 1.0.0
  */
 /**
  * Feature Flag Module
@@ -56,8 +55,8 @@ export declare class FeatureFlagModule {
      * @Module({
      *   imports: [
      *     FeatureFlagModule.forRoot({
-     *       provider: 'redis',
-     *       cacheEnabled: true,
+     *       provider: 'database',
+     *       isCacheEnabled: true,
      *       cacheTtl: 600,
      *     })
      *   ],

package/dist/backend/featureFlags/feature-flag.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flag.module.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAMa,iBAAiB;IAC5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;QACvB,QAAQ,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;QAC5D,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,GAAG;QACF,MAAM,EAAE,OAAO,iBAAiB,CAAC;QACjC,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;IAiBD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;KAC9C,GAAG;QACF,MAAM,EAAE,OAAO,iBAAiB,CAAC;QACjC,OAAO,EAAE,OAAO,EAAE,CAAC;QACnB,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;CAgBF"}
+{"version":3,"file":"feature-flag.module.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAMa,iBAAiB;IAC5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;QACvB,QAAQ,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;QAC5D,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,GAAG;QACF,MAAM,EAAE,OAAO,iBAAiB,CAAC;QACjC,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;IAkBD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;KAC9C,GAAG;QACF,MAAM,EAAE,OAAO,iBAAiB,CAAC;QACjC,OAAO,EAAE,OAAO,EAAE,CAAC;QACnB,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;CAgBF"}