@plyaz/core 1.1.1 → 1.2.1

package/dist/backend/featureFlags/config/validation.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Configuration Validation Utilities
+ *
+ * Validation utilities for feature flag configuration in NestJS applications.
+ * Provides error reporting and environment-specific validation.
+ *
+ */
+import { type CoreFeatureFlagEnvironmentConfig, type CoreFeatureFlagValidationResult } from '@plyaz/types/core';
+/**
+ * FeatureFlagConfigValidator - Comprehensive configuration validation for feature flags
+ *
+ * @description Validates feature flag configuration objects to ensure they meet system requirements
+ * and best practices. Provides detailed error reporting and warnings for potential issues.
+ *
+ * **Validation Categories:**
+ * - Provider validation (memory, file, redis, api, database)
+ * - Cache configuration validation
+ * - Database connection validation
+ * - Environment-specific settings validation
+ *
+ * **Usage Flow:**
+ * 1. Configuration is loaded from environment variables
+ * 2. Validator checks all settings for correctness
+ * 3. Errors prevent system startup
+ * 4. Warnings are logged but don't block startup
+ *
+ * @example Basic Validation
+ * ```typescript
+ * const config = {
+ *   provider: 'database',
+ *   isCacheEnabled: true,
+ *   cacheTtl: 300,
+ *   databaseConfig: {
+ *     connectionString: 'https://project.supabase.co',
+ *     tableName: 'feature_flags'
+ *   }
+ * };
+ *
+ * const result = FeatureFlagConfigValidator.validate(config);
+ *
+ * if (result.isValid) {
+ *   console.log('Configuration is valid!');
+ * } else {
+ *   console.error('Configuration errors:', result.errors);
+ * }
+ * ```
+ *
+ * @example Error Handling
+ * ```typescript
+ * try {
+ *   FeatureFlagConfigValidator.validateOrThrow(config);
+ *   // Configuration is valid, proceed with initialization
+ * } catch (error) {
+ *   console.error('Invalid configuration:', error.message);
+ *   process.exit(1);
+ * }
+ * ```
+ */
+export declare class FeatureFlagConfigValidator {
+    /**
+     * Validates feature flag configuration and returns detailed results
+     *
+     * @description Performs comprehensive validation of feature flag configuration,
+     * checking all aspects including provider settings, cache configuration,
+     * database connections, and environment-specific settings.
+     *
+     * @param {FeatureFlagEnvironmentConfig} config - Configuration object to validate
+     * @returns {ValidationResult} Validation result with errors and warnings
+     *
+     * @example Successful Validation
+     * ```typescript
+     * const validConfig = {
+     *   provider: 'memory',
+     *   isCacheEnabled: true,
+     *   cacheTtl: 300,
+     *   refreshInterval: 60
+     * };
+     *
+     * const result = FeatureFlagConfigValidator.validate(validConfig);
+     * // result.isValid = true
+     * // result.errors = []
+     * // result.warnings = []
+     * ```
+     *
+     * @example Validation with Errors
+     * ```typescript
+     * const invalidConfig = {
+     *   provider: 'invalid_provider', // Error: invalid provider
+     *   cacheTtl: -100,              // Error: negative TTL
+     *   databaseConfig: {            // Error: missing connection string
+     *     tableName: 'flags'
+     *   }
+     * };
+     *
+     * const result = FeatureFlagConfigValidator.validate(invalidConfig);
+     * // result.isValid = false
+     * // result.errors = [
+     * //   { field: 'provider', message: 'Invalid provider...', code: 'INVALID_PROVIDER' },
+     * //   { field: 'cacheTtl', message: 'Cache TTL must be non-negative', code: 'INVALID_CACHE_TTL' }
+     * // ]
+     * ```
+     *
+     * @example Validation with Warnings
+     * ```typescript
+     * const configWithWarnings = {
+     *   provider: 'database',
+     *   cacheTtl: 7200, // Warning: very high TTL
+     *   isLoggingEnabled: true, // Warning: logging in production
+     *   databaseConfig: {
+     *     connectionString: 'https://project.supabase.co',
+     *     tableName: 'feature_flags'
+     *   }
+     * };
+     *
+     * process.env.NODE_ENV = 'production';
+     * const result = FeatureFlagConfigValidator.validate(configWithWarnings);
+     * // result.isValid = true (warnings don't fail validation)
+     * // result.warnings = [
+     * //   { field: 'cacheTtl', message: 'Cache TTL is very high...', code: 'HIGH_CACHE_TTL' },
+     * //   { field: 'isLoggingEnabled', message: 'Logging is enabled in production...', code: 'PRODUCTION_LOGGING_ENABLED' }
+     * // ]
+     * ```
+     */
+    static validate(config: CoreFeatureFlagEnvironmentConfig): CoreFeatureFlagValidationResult;
+    private static validateProvider;
+    private static validateCacheSettings;
+    private static validateDatabaseConfig;
+    private static validateConnectionString;
+    private static validateTableName;
+    private static validatePoolSize;
+    private static validateTimeout;
+    private static getWarnings;
+    /**
+     * Validates configuration and throws error if validation fails
+     *
+     * @description Convenience method that validates configuration and throws a detailed
+     * error if validation fails. This is typically used during application startup
+     * to ensure the system doesn't start with invalid configuration.
+     *
+     * @param {FeatureFlagEnvironmentConfig} config - Configuration to validate
+     * @throws {DatabasePackageError} When validation fails with detailed error messages
+     *
+     * @example Startup Validation
+     * ```typescript
+     * // In FeatureFlagService.onModuleInit()
+     * try {
+     *   const config = FeatureFlagConfigFactory.fromOptions();
+     *   FeatureFlagConfigValidator.validateOrThrow(config);
+     *
+     *   // Configuration is valid, proceed with initialization
+     *   this.provider = FeatureFlagProviderFactory.create(config, FEATURES);
+     *   await this.provider.initialize();
+     * } catch (error) {
+     *   this.logger.error('Configuration validation failed:', error.message);
+     *   throw error; // Prevent service from starting
+     * }
+     * ```
+     *
+     * @example Error Output
+     * ```typescript
+     * // When validation fails, throws DatabasePackageError with message:
+     * // "Configuration validation failed:
+     * // provider: Invalid provider: invalid_type. Must be one of: memory, file, redis, api, database
+     * // cacheTtl: Cache TTL must be non-negative
+     * // databaseConfig.connectionString: Database connection string is required"
+     * ```
+     *
+     * @example Environment Variable Validation
+     * ```bash
+     * # Missing required environment variables:
+     * # SUPABASE_URL=  # Empty/missing
+     * # FEATURE_FLAG_PROVIDER=database
+     *
+     * # Results in error:
+     * # "Configuration validation failed:
+     * # databaseConfig.connectionString: Database connection string is required"
+     * ```
+     */
+    static validateOrThrow(config: CoreFeatureFlagEnvironmentConfig): void;
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/backend/featureFlags/config/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/config/validation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,KAAK,gCAAgC,EACrC,KAAK,+BAA+B,EACrC,MAAM,mBAAmB,CAAC;AAY3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,0BAA0B;IACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,gCAAgC,GAAG,+BAA+B;IAiC1F,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAY/B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAkBpC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiBrC,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAoBvC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAUhC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B,OAAO,CAAC,MAAM,CAAC,eAAe;IAU9B,OAAO,CAAC,MAAM,CAAC,WAAW;IAqC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,gCAAgC,GAAG,IAAI;CAYvE"}

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

@@ -2,13 +2,12 @@
  * Feature Flag Controller
  *
  * NestJS controller for feature flag management.
- * Provides REST API endpoints for feature flag operations.
+ * Uses the domain FeatureFlagService directly.
  *
  * @fileoverview NestJS controller for feature flags
- * @version 1.0.0
  */
-import type { FeatureFlagValue, FeatureFlagContext, FeatureFlagEvaluation, FeatureFlag, FeatureFlagRule } from '@plyaz/types';
-import type { FeatureFlagService } from './feature-flag.service';
+import type { FeatureFlagValue, FeatureFlagContext, FeatureFlagEvaluation, FeatureFlag, FeatureFlagRule, CreateFlagRequest } from '@plyaz/types';
+import { FeatureFlagService } from '@domain/featureFlags';
 import type { FeatureFlagKey } from '@domain/types';
 /**
  * Request DTO for flag evaluation.
@@ -16,21 +15,11 @@ import type { FeatureFlagKey } from '@domain/types';
 interface EvaluateFlagRequest {
     context?: FeatureFlagContext;
 }
-/**
- * Request DTO for creating/updating flags.
- */
-interface CreateFlagRequest {
-    name: string;
-    description?: string;
-    value: FeatureFlagValue;
-    isEnabled?: boolean;
-    environment?: 'all' | 'development' | 'staging' | 'production';
-    rolloutPercentage?: number;
-}
 /**
  * Feature Flag Controller
  *
  * Provides REST endpoints for feature flag management and evaluation.
+ * Uses the domain FeatureFlagService directly.
  *
  * @example
  * ```typescript
@@ -41,87 +30,49 @@ interface CreateFlagRequest {
  */
 export declare class FeatureFlagController {
     private readonly featureFlagService;
-    constructor(featureFlagService: FeatureFlagService);
+    constructor(featureFlagService: FeatureFlagService<FeatureFlagKey>);
     /**
      * Evaluates a feature flag for the given context.
-     *
-     * @param key - Feature flag key
-     * @param body - Evaluation context
-     * @returns Feature flag evaluation result
      */
     evaluateFlag(key: FeatureFlagKey, body?: EvaluateFlagRequest): Promise<FeatureFlagEvaluation<FeatureFlagKey>>;
     /**
      * Checks if a feature flag is enabled.
-     *
-     * @param key - Feature flag key
-     * @param body - Evaluation context
-     * @returns Boolean indicating if flag is enabled
      */
     isEnabled(key: FeatureFlagKey, body?: EvaluateFlagRequest): Promise<{
         isEnabled: boolean;
     }>;
     /**
      * Gets all feature flags with their evaluations.
-     *
-     * @param body - Evaluation context
-     * @returns All feature flag evaluations
      */
     evaluateAllFlags(body?: EvaluateFlagRequest): Promise<Record<string, FeatureFlagEvaluation<FeatureFlagKey>>>;
     /**
      * Creates a new feature flag.
-     *
-     * @param key - Feature flag key
-     * @param createData - Flag creation data
-     * @returns Created feature flag
      */
-    createFlag(createData: CreateFlagRequest & {
-        key: FeatureFlagKey;
-    }): Promise<FeatureFlag<FeatureFlagKey>>;
+    createFlag(createData: CreateFlagRequest<FeatureFlagKey>): Promise<FeatureFlag<FeatureFlagKey>>;
     /**
      * Updates an existing feature flag.
-     *
-     * @param key - Feature flag key
-     * @param updateData - Flag update data
-     * @returns Updated feature flag
      */
-    updateFlag(key: FeatureFlagKey, updateData: Partial<CreateFlagRequest>): Promise<FeatureFlag<FeatureFlagKey>>;
+    updateFlag(key: FeatureFlagKey, updateData: Partial<CreateFlagRequest<FeatureFlagKey>>): Promise<FeatureFlag<FeatureFlagKey>>;
     /**
      * Deletes a feature flag.
-     *
-     * @param key - Feature flag key
      */
     deleteFlag(key: FeatureFlagKey): Promise<{
         isSuccessful: boolean;
     }>;
     /**
      * Sets a manual override for a flag.
-     *
-     * @param key - Feature flag key
-     * @param value - Override value
      */
     setOverride(key: FeatureFlagKey, value: FeatureFlagValue): Promise<{
         isSuccessful: boolean;
     }>;
     /**
      * Removes a manual override for a flag.
-     *
-     * @param key - Feature flag key
      */
     removeOverride(key: FeatureFlagKey): Promise<{
         isSuccessful: boolean;
     }>;
-    /**
-     * Gets all available feature flags.
-     *
-     * @param environment - Filter by environment
-     * @returns List of feature flags
-     */
-    getAllFeatureFlags(environment?: string): Promise<FeatureFlag<FeatureFlagKey>[]>;
     /**
      * Gets all rules for a specific flag.
-     *
-     * @param key - Feature flag key
-     * @returns List of rules for the flag
      */
     getFlagRules(key: FeatureFlagKey): Promise<FeatureFlagRule<FeatureFlagKey>[]>;
     /**
@@ -130,6 +81,13 @@ export declare class FeatureFlagController {
     refreshCache(): Promise<{
         isSuccessful: boolean;
     }>;
+    /**
+     * Gets service health status.
+     */
+    getHealth(): Promise<{
+        isInitialized: boolean;
+        provider: string;
+    }>;
 }
 export {};
 //# sourceMappingURL=feature-flag.controller.d.ts.map

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,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAwB,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,qBACa,qBAAqB;IAG9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB,CAAC,cAAc,CAAC;IAGzE;;OAEG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;IAYjD;;OAEG;IAEG,SAAS,CACC,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAalC;;OAEG;IAEG,gBAAgB,CACZ,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC;IAYjE;;OAEG;IAEG,UAAU,CACN,UAAU,EAAE,iBAAiB,CAAC,cAAc,CAAC,GACpD,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAYvC;;OAEG;IAEG,UAAU,CACA,GAAG,EAAE,cAAc,EACzB,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,GAC7D,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAYvC;;OAEG;IAEG,UAAU,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAavF;;OAEG;IAEG,WAAW,CACD,GAAG,EAAE,cAAc,EAClB,KAAK,EAAE,gBAAgB,GACrC,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAarC;;OAEG;IAEG,cAAc,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAa3F;;OAEG;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;IAaxD;;OAEG;IAEG,SAAS,IAAI,OAAO,CAAC;QACzB,aAAa,EAAE,OAAO,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CAMH"}

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

@@ -1,62 +1,69 @@
 /**
- * Feature Flag Module
+ * Feature Flag NestJS Module
  *
- * NestJS module for feature flag functionality.
- * Configures providers, controllers, and dependencies.
+ * NestJS wrapper around the unified FeatureFlagModule.
+ * Adds the controller for REST API endpoints.
  *
- * @fileoverview NestJS module for feature flags
- * @version 1.0.0
+ * @example
+ * ```typescript
+ * import { FeatureFlagModule } from '@plyaz/core/backend/featureFlags';
+ *
+ * @Module({
+ *   imports: [FeatureFlagModule.forRoot({ provider: 'database' })],
+ * })
+ * export class AppModule {}
+ * ```
  */
+import { type DynamicModule, type OnModuleDestroy, type Type, type ForwardReference, type InjectionToken } from '@nestjs/common';
+import { CoreFeatureFlagModuleConfig } from '@plyaz/types/core';
 /**
  * Feature Flag Module
  *
  * Provides feature flag functionality as a NestJS module.
- * Can be imported by other modules to access feature flag services.
+ * Uses the domain FeatureFlagService directly - no NestJS wrapper needed.
  *
  * @example
  * ```typescript
  * // In your app.module.ts
- * import { FeatureFlagModule } from '@plyaz/config/backend/featureFlags';
- *
  * @Module({
- *   imports: [FeatureFlagModule],
- *   // ... other module configuration
+ *   imports: [
+ *     FeatureFlagModule.forRoot({ provider: 'database' })
+ *   ],
  * })
  * export class AppModule {}
  * ```
  *
  * @example
  * ```typescript
- * // In your service
- * import { FeatureFlagService } from '@plyaz/config/backend/featureFlags';
- *
+ * // In your service - inject the domain service
  * @Injectable()
  * export class MyService {
- *   constructor(private readonly featureFlagService: FeatureFlagService) {}
+ *   constructor(
+ *     @Inject(FEATURE_FLAG_SERVICE)
+ *     private readonly featureFlagService: FeatureFlagService<FeatureFlagKey>
+ *   ) {}
  *
  *   async doSomething() {
  *     const isEnabled = await this.featureFlagService.isEnabled('MY_FEATURE');
- *     if (isEnabled) {
- *       // Execute new feature logic
- *     }
  *   }
  * }
  * ```
  */
-export declare class FeatureFlagModule {
+export declare class FeatureFlagModule implements OnModuleDestroy {
+    private static serviceInstance;
+    onModuleDestroy(): void;
     /**
-     * Static method for importing the module with configuration.
-     * This allows customization of the feature flag system.
+     * Creates the module with configuration.
      *
      * @param options - Module configuration options
-     * @returns Configured module
+     * @returns Configured dynamic module
      *
      * @example
      * ```typescript
      * @Module({
      *   imports: [
      *     FeatureFlagModule.forRoot({
-     *       provider: 'redis',
+     *       provider: 'database',
      *       cacheEnabled: true,
      *       cacheTtl: 600,
      *     })
@@ -65,23 +72,13 @@ export declare class FeatureFlagModule {
      * export class AppModule {}
      * ```
      */
-    static forRoot(options?: {
-        provider?: 'memory' | 'database' | 'redis' | 'api' | 'file';
-        isCacheEnabled?: boolean;
-        cacheTtl?: number;
-        refreshInterval?: number;
-        isLoggingEnabled?: boolean;
-    }): {
-        module: typeof FeatureFlagModule;
-        providers: unknown[];
-        exports: unknown[];
-    };
+    static forRoot(options?: CoreFeatureFlagModuleConfig): DynamicModule;
     /**
-     * Static method for importing the module asynchronously.
+     * Creates the module with async configuration.
      * Useful when configuration depends on other services.
      *
      * @param options - Async module configuration options
-     * @returns Configured async module
+     * @returns Configured async dynamic module
      *
      * @example
      * ```typescript
@@ -101,14 +98,9 @@ export declare class FeatureFlagModule {
      * ```
      */
     static forRootAsync(options: {
-        imports?: unknown[];
-        inject?: unknown[];
-        useFactory?: (...args: unknown[]) => unknown;
-    }): {
-        module: typeof FeatureFlagModule;
-        imports: unknown[];
-        providers: unknown[];
-        exports: unknown[];
-    };
+        imports?: Array<Type<unknown> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+        inject?: InjectionToken[];
+        useFactory: (...args: unknown[]) => CoreFeatureFlagModuleConfig | Promise<CoreFeatureFlagModuleConfig>;
+    }): DynamicModule;
 }
 //# sourceMappingURL=feature-flag.module.d.ts.map

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;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,IAAI,EACT,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAIa,iBAAkB,YAAW,eAAe;IACvD,OAAO,CAAC,MAAM,CAAC,eAAe,CAAmD;IAEjF,eAAe,IAAI,IAAI;IAOvB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,2BAAgC,GAAG,aAAa;IAgBxE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,GAAG,gBAAgB,CAAC,CAAC;QAC3F,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;QAC1B,UAAU,EAAE,CACV,GAAG,IAAI,EAAE,OAAO,EAAE,KACf,2BAA2B,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;KACzE,GAAG,aAAa;CAkBlB"}

package/dist/backend/featureFlags/guards/feature-flag.guard.d.ts

@@ -0,0 +1,33 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import type { FeatureFlagKey } from '@domain/types';
+import { FeatureFlagService } from '@domain/featureFlags';
+/**
+ * Guard that ensures a feature flag is in the expected state
+ * before allowing access to a route handler.
+ *
+ * @example
+ * ```typescript
+ * @Controller('premium')
+ * @UseGuards(FeatureFlagGuard)
+ * export class PremiumController {
+ *   @Get()
+ *   @FeatureEnabled('PREMIUM_FEATURE')
+ *   getPremiumData() {
+ *     // Only accessible if PREMIUM_FEATURE is enabled
+ *   }
+ * }
+ * ```
+ */
+export declare class FeatureFlagGuard implements CanActivate {
+    private readonly reflector;
+    private readonly featureFlagService;
+    private readonly logger;
+    constructor(reflector: Reflector, featureFlagService: FeatureFlagService<FeatureFlagKey>);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    /**
+     * Compare expected vs actual values.
+     */
+    private matches;
+}
+//# sourceMappingURL=feature-flag.guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.guard.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/guards/feature-flag.guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,WAAW,EAAE,gBAAgB,EAAU,MAAM,gBAAgB,CAAC;AAEnF,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAQzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAwB,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAGhF;;;;;;;;;;;;;;;;GAgBG;AACH,qBACa,gBAAiB,YAAW,WAAW;IAOhD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAE1B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IARrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAGpB;gBAGgB,SAAS,EAAE,SAAS,EAEpB,kBAAkB,EAAE,kBAAkB,CAAC,cAAc,CAAC;IAGnE,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IA+B9D;;OAEG;IACH,OAAO,CAAC,OAAO;CAUhB"}

package/dist/backend/featureFlags/index.d.ts

@@ -1,49 +1,22 @@
 /**
- * Feature Flag Backend - Main Exports
+ * Feature Flag Backend - NestJS Exports
  *
- * NestJS backend exports for feature flag functionality.
- * Provides controllers, services, repositories, and module for easy integration.
+ * NestJS module with controller, guards, decorators, and interceptors.
+ * Uses shared service factory from domain.
  *
  * @fileoverview Backend feature flags exports
- * @version 1.0.0
  */
+export { FeatureFlagDomainService } from './FeatureFlagDomainService';
 export { FeatureFlagModule } from './feature-flag.module';
-export { FeatureFlagService } from './feature-flag.service';
-export { FeatureFlagRepository } from './feature-flag.repository';
 export { FeatureFlagController } from './feature-flag.controller';
-/**
- * NestJS Guard for feature flag protection.
- * Use this to protect routes based on feature flag status.
- *
- * @example
- * ```typescript
- * import { UseGuards } from '@nestjs/common';
- * import { FeatureFlagGuard } from '@plyaz/config/backend/featureFlags';
- *
- * @UseGuards(FeatureFlagGuard('BETA_API'))
- * @Get('beta-endpoint')
- * async betaEndpoint() {
- *   // This endpoint is only accessible when BETA_API flag is enabled
- * }
- * ```
- */
-export declare function FeatureFlagGuard(): (_target: object, _propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * NestJS Decorator for feature flag checking.
- * Use this to check feature flags within methods.
- *
- * @example
- * ```typescript
- * import { FeatureFlag } from '@plyaz/config/backend/featureFlags';
- *
- * @Injectable()
- * export class MyService {
- *   @FeatureFlag('NEW_ALGORITHM')
- *   async processData(data: any) {
- *     // This method behavior can be controlled by the NEW_ALGORITHM flag
- *   }
- * }
- * ```
- */
-export declare function FeatureFlag(): (_target: object, _propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export { FeatureFlagService, FeatureFlagServiceFactory } from '@domain/featureFlags';
+export { FeatureDisabled } from './decorators/feature-disabled.decorator';
+export { FeatureEnabled } from './decorators/feature-enabled.decorator';
+export { FeatureFlagGuard } from './guards/feature-flag.guard';
+export { FeatureFlagMiddleware } from './middleware/feature-flag-middleware';
+export { FeatureFlagLoggingInterceptor } from './interceptors/feature-flag-logging-interceptor';
+export { ErrorHandlingInterceptor } from './interceptors/error-handling-interceptor';
+export { FeatureFlagConfigFactory } from './config/feature-flag.config';
+export { FeatureFlagConfigValidator } from './config/validation';
+export { FeatureFlagDatabaseRepository } from '@models/featureFlags';
 //# sourceMappingURL=index.d.ts.map

package/dist/backend/featureFlags/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGlE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,KAI5B,SAAS,MAAM,EACf,eAAe,MAAM,EACrB,YAAY,kBAAkB,KAC7B,kBAAkB,CAKtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,KAIvB,SAAS,MAAM,EACf,eAAe,MAAM,EACrB,YAAY,kBAAkB,KAC7B,kBAAkB,CAKtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAGrF,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAGxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAG7E,OAAO,EAAE,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAChG,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAGrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAGjE,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/backend/featureFlags/interceptors/error-handling-interceptor.d.ts

@@ -0,0 +1,16 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+/**
+ * Interceptor to enforce feature flag rules in real-time.
+ *
+ * FLOW:
+ * 1. Runs AFTER middleware has attached feature flags to the request.
+ * 2. Checks if the requested feature is enabled.
+ * 3. If disabled, blocks the request with an HTTP 403.
+ * 4. If enabled, passes the request to the controller/service.
+ */
+export declare class ErrorHandlingInterceptor implements NestInterceptor {
+    private readonly logger;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}
+//# sourceMappingURL=error-handling-interceptor.d.ts.map