@plyaz/core 1.1.0 → 1.2.0

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

@@ -0,0 +1,111 @@
+/**
+ * Feature Flag Configuration
+ *
+ * Configuration integration for feature flags with environment variable support.
+ * Imports configuration from .env.local and provides validation.
+ *
+ */
+import { type FeatureFlagEnvironmentConfig } from '@plyaz/types';
+/**
+ * Feature flag configuration factory
+ *
+ * This factory is the FIRST component called during application startup.
+ * It reads environment variables from .env.local and creates a validated configuration object.
+ *
+ * @example
+ * ```typescript
+ * // Step 1: Called automatically by FeatureFlagService.onModuleInit()
+ * const config = FeatureFlagConfigFactory.fromEnvironment();
+ *
+ * // Step 2: Configuration is validated
+ * // Step 3: Provider is created with this config
+ * const provider = FeatureFlagProviderFactory.create(config, FEATURES);
+ * ```
+ *
+ * @example Environment Variables (.env.local)
+ * ```bash
+ * SUPABASE_URL=https://your-project.supabase.co
+ * SUPABASE_ANON_PUBLIC_KEY=your-anon-key
+ * FEATURE_FLAG_PROVIDER=database
+ * FEATURE_FLAG_CACHE_ENABLED=true
+ * FEATURE_FLAG_CACHE_TTL=300
+ * FEATURE_FLAG_TABLE_NAME=feature_flags
+ * ```
+ */
+export declare class FeatureFlagConfigFactory {
+    /**
+     * Creates configuration from environment variables
+     *
+     * **EXECUTION ORDER: This is called FIRST in the initialization chain**
+     *
+     * Flow:
+     * 1. NestJS starts → FeatureFlagModule loads
+     * 2. FeatureFlagService.onModuleInit() called
+     * 3. → initializeProvider() called
+     * 4. → **THIS METHOD CALLED** ← YOU ARE HERE
+     * 5. → Configuration validated
+     * 6. → Provider created and initialized
+     * 7. → Database connection established
+     *
+     * @returns Validated configuration object ready for provider creation
+     * @throws {FeatureFlagConfigError} If environment variables are missing or invalid
+     *
+     * @example
+     * ```typescript
+     * // This method reads from process.env and creates:
+     * {
+     *   provider: 'database',
+     *   isCacheEnabled: true,
+     *   cacheTtl: 300,
+     *   databaseConfig: {
+     *     connectionString: 'https://your-project.supabase.co',
+     *     tableName: 'feature_flags',
+     *     poolSize: 10,
+     *     timeout: 30000
+     *   }
+     * }
+     * ```
+     */
+    static fromEnvironment(): FeatureFlagEnvironmentConfig;
+    /**
+     * Determines which provider to use - now uses constants instead of environment variables
+     *
+     * @private
+     * @returns Provider type from constants
+     */
+    private static getProvider;
+    private static getCacheEnabled;
+    private static getCacheTtl;
+    private static getRefreshInterval;
+    private static getLoggingEnabled;
+    /**
+     * Creates database configuration from environment variables
+     *
+     * **CRITICAL**: This method requires SUPABASE_URL to be set in .env.local
+     *
+     * @private
+     * @returns Database configuration object
+     * @throws {FeatureFlagConfigError} If SUPABASE_URL is missing
+     *
+     * @example Environment Variables Required:
+     * ```bash
+     * SUPABASE_URL=https://your-project.supabase.co          # REQUIRED
+     * SUPABASE_ANON_PUBLIC_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... # Used in connection
+     * FEATURE_FLAG_TABLE_NAME=feature_flags                           # Optional, defaults to 'feature_flags'
+     * DB_POOL_SIZE=10                                                 # Optional, defaults to 10
+     * DB_TIMEOUT=30000                                                # Optional, defaults to 30000ms
+     * ```
+     *
+     * @example Generated Configuration:
+     * ```typescript
+     * {
+     *   connectionString: 'https://your-project.supabase.co',
+     *   tableName: 'feature_flags',
+     *   poolSize: 10,
+     *   timeout: 30000
+     * }
+     * ```
+     */
+    private static getDatabaseConfig;
+}
+//# sourceMappingURL=feature-flag.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.config.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/config/feature-flag.config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAKL,KAAK,4BAA4B,EAGlC,MAAM,cAAc,CAAC;AAItB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,wBAAwB;IACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,MAAM,CAAC,eAAe,IAAI,4BAA4B;IAmBtD;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,eAAe;IAI9B,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAIjC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAOhC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAgBjC"}

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 FeatureFlagEnvironmentConfig, type FeatureFlagValidationResult } from '@plyaz/types';
+/**
+ * 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: FeatureFlagEnvironmentConfig): FeatureFlagValidationResult;
+    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 {DatabaseError} When validation fails with detailed error messages
+     *
+     * @example Startup Validation
+     * ```typescript
+     * // In FeatureFlagService.onModuleInit()
+     * try {
+     *   const config = FeatureFlagConfigFactory.fromEnvironment();
+     *   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 DatabaseError 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: FeatureFlagEnvironmentConfig): 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,EAEL,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAGjC,MAAM,cAAc,CAAC;AAKtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,0BAA0B;IACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,4BAA4B,GAAG,2BAA2B;IAiClF,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;IA+B1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,4BAA4B,GAAG,IAAI;CAYnE"}

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

@@ -0,0 +1,321 @@
+import { type DatabaseServiceInterface, type Transaction } from '@plyaz/types/db';
+/**
+ * DatabaseConnectionManager - Singleton manager for feature flag database connections
+ *
+ * @description Manages Supabase database connections for the feature flag system using a singleton pattern.
+ * Handles connection initialization, table registration, transactions, and cleanup. This is the core
+ * database layer that all feature flag operations depend on.
+ *
+ * **Initialization Flow:**
+ * 1. FeatureFlagService calls initialize() during onModuleInit()
+ * 2. Reads Supabase credentials from environment variables
+ * 3. Creates database service with @plyaz/db
+ * 4. Registers feature flag tables
+ * 5. Enables caching and other optimizations
+ *
+ * **Required Environment Variables:**
+ * - SUPABASE_URL: Your Supabase project URL
+ * - SUPABASE_SERVICE_ROLE_KEY: Service role key for admin operations
+ * - SUPABASE_ANON_PUBLIC_KEY: Anonymous key for public operations
+ *
+ * @example Environment Setup (.env.local)
+ * ```bash
+ * SUPABASE_URL=https://your-project.supabase.co
+ * SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+ * SUPABASE_ANON_PUBLIC_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+ * ```
+ *
+ * @example Basic Usage (Internal - called by FeatureFlagService)
+ * ```typescript
+ * // During system initialization:
+ * const manager = DatabaseConnectionManager.getInstance();
+ * await manager.initialize();
+ *
+ * // During runtime operations:
+ * const db = manager.getDatabase();
+ * const flags = await db.query('feature_flags', { limit: 100 });
+ * ```
+ *
+ * @example Transaction Usage
+ * ```typescript
+ * const manager = DatabaseConnectionManager.getInstance();
+ *
+ * // Atomic flag creation with rules
+ * const result = await manager.transaction(async (tx) => {
+ *   // Create flag
+ *   const flag = await tx.create('feature_flags', {
+ *     key: 'NEW_FEATURE',
+ *     value: true,
+ *     is_enabled: true
+ *   });
+ *
+ *   // Create associated rule
+ *   const rule = await tx.create('feature_flag_rules', {
+ *     flag_key: 'NEW_FEATURE',
+ *     name: 'Premium Users Only',
+ *     conditions: [{ field: 'userRole', operator: 'equals', value: 'premium' }]
+ *   });
+ *
+ *   return { flag, rule };
+ * });
+ * ```
+ *
+ */
+export declare class DatabaseConnectionManager {
+    private static instance;
+    private databaseService;
+    private constructor();
+    /**
+     * Gets the singleton instance of DatabaseConnectionManager
+     *
+     * @description Returns the single instance of the connection manager, creating it if it doesn't exist.
+     * This ensures only one database connection pool is maintained across the application.
+     *
+     * @returns {DatabaseConnectionManager} The singleton instance
+     *
+     * @example Getting the Instance
+     * ```typescript
+     * // Always returns the same instance
+     * const manager1 = DatabaseConnectionManager.getInstance();
+     * const manager2 = DatabaseConnectionManager.getInstance();
+     * console.log(manager1 === manager2); // true
+     *
+     * // Use in services
+     * class FeatureFlagRepository {
+     *   private connectionManager = DatabaseConnectionManager.getInstance();
+     *
+     *   async getFlags() {
+     *     const db = this.connectionManager.getDatabase();
+     *     return db.query('feature_flags');
+     *   }
+     * }
+     * ```
+     */
+    static getInstance(): DatabaseConnectionManager;
+    /**
+     * Initializes the database connection and registers feature flag tables
+     *
+     * @description Sets up the Supabase connection using environment variables and registers
+     * all feature flag related tables. This method is idempotent - calling it multiple
+     * times won't create additional connections.
+     *
+     * **What it does:**
+     * 1. Validates required environment variables
+     * 2. Creates Supabase database service
+     * 3. Configures caching (5-minute TTL)
+     * 4. Registers feature flag tables with proper ID columns
+     * 5. Disables audit logging (until tables are created)
+     *
+     * @throws {DatabaseError} When environment variables are missing or connection fails
+     *
+     * @example Initialization Process
+     * ```typescript
+     * // Called automatically by FeatureFlagService.onModuleInit()
+     * const manager = DatabaseConnectionManager.getInstance();
+     *
+     * try {
+     *   await manager.initialize();
+     *   console.log('Database connection established');
+     * } catch (error) {
+     *   console.error('Failed to connect to database:', error.message);
+     *   // Error: Missing environment variables for Supabase connection
+     * }
+     * ```
+     *
+     * @example Environment Variable Validation
+     * ```typescript
+     * // If any of these are missing, initialization fails:
+     * // SUPABASE_URL=undefined
+     * // SUPABASE_SERVICE_ROLE_KEY=undefined
+     * // SUPABASE_ANON_PUBLIC_KEY=undefined
+     *
+     * // Throws: DatabaseError with code CONFIG_REQUIRED
+     * ```
+     *
+     * @example Registered Tables
+     * ```typescript
+     * // These tables are automatically registered:
+     * // - feature_flags (ID: key)
+     * // - feature_flag_rules (ID: id)
+     * // - feature_flag_overrides (ID: id)
+     * // - feature_flag_evaluations (ID: id)
+     * ```
+     */
+    initialize(): Promise<void>;
+    /**
+     * Gets the initialized database service instance
+     *
+     * @description Returns the database service for performing queries. The database must be
+     * initialized first using initialize() method, otherwise this will throw an error.
+     *
+     * @returns {DatabaseServiceInterface} The database service instance
+     * @throws {DatabaseError} When database is not initialized
+     *
+     * @example Basic Usage
+     * ```typescript
+     * const manager = DatabaseConnectionManager.getInstance();
+     * await manager.initialize(); // Must initialize first
+     *
+     * const db = manager.getDatabase();
+     *
+     * // Query feature flags
+     * const result = await db.query('feature_flags', {
+     *   filters: [{ field: 'is_enabled', operator: 'eq', value: true }],
+     *   sort: [{ field: 'key', direction: 'asc' }]
+     * });
+     *
+     * if (result.success) {
+     *   console.log('Found flags:', result.value.data);
+     * }
+     * ```
+     *
+     * @example Error Handling
+     * ```typescript
+     * const manager = DatabaseConnectionManager.getInstance();
+     * // Don't call initialize()
+     *
+     * try {
+     *   const db = manager.getDatabase();
+     * } catch (error) {
+     *   console.error(error.message);
+     *   // "Database not initialized. Call initialize() first."
+     * }
+     * ```
+     *
+     * @example CRUD Operations
+     * ```typescript
+     * const db = manager.getDatabase();
+     *
+     * // Create a flag
+     * const createResult = await db.create('feature_flags', {
+     *   key: 'NEW_FEATURE',
+     *   value: true,
+     *   is_enabled: true
+     * });
+     *
+     * // Update a flag
+     * const updateResult = await db.update('feature_flags', 'NEW_FEATURE', {
+     *   value: false
+     * });
+     *
+     * // Delete a flag
+     * const deleteResult = await db.delete('feature_flags', 'NEW_FEATURE');
+     * ```
+     */
+    getDatabase(): DatabaseServiceInterface;
+    /**
+     * Executes a database transaction with automatic rollback on failure
+     *
+     * @description Provides atomic database operations by wrapping multiple queries in a transaction.
+     * If any operation fails, all changes are rolled back automatically. This is essential for
+     * maintaining data consistency when creating flags with rules or performing bulk operations.
+     *
+     * @template T The return type of the transaction callback
+     * @param {Function} callback - Function that receives transaction object and performs operations
+     * @returns {Promise<T>} The result of the transaction callback
+     * @throws {DatabaseError} When transaction fails or returns no value
+     *
+     * @example Atomic Flag Creation with Rules
+     * ```typescript
+     * const manager = DatabaseConnectionManager.getInstance();
+     *
+     * const result = await manager.transaction(async (tx) => {
+     *   // Create the flag
+     *   const flag = await tx.create('feature_flags', {
+     *     key: 'PREMIUM_CHECKOUT',
+     *     value: true,
+     *     is_enabled: true,
+     *     description: 'Premium checkout flow'
+     *   });
+     *
+     *   // Create targeting rule
+     *   const rule = await tx.create('feature_flag_rules', {
+     *     flag_key: 'PREMIUM_CHECKOUT',
+     *     name: 'Premium Users Only',
+     *     conditions: [
+     *       { field: 'userRole', operator: 'equals', value: 'premium' },
+     *       { field: 'subscriptionActive', operator: 'equals', value: true }
+     *     ],
+     *     value: true,
+     *     priority: 100
+     *   });
+     *
+     *   return { flag, rule };
+     * });
+     *
+     * console.log('Created flag and rule:', result);
+     * ```
+     *
+     * @example Bulk Flag Updates
+     * ```typescript
+     * const flagsToUpdate = ['FEATURE_A', 'FEATURE_B', 'FEATURE_C'];
+     *
+     * await manager.transaction(async (tx) => {
+     *   for (const flagKey of flagsToUpdate) {
+     *     await tx.update('feature_flags', flagKey, {
+     *       is_enabled: false,
+     *       updated_at: new Date().toISOString()
+     *     });
+     *   }
+     *
+     *   // Log the bulk update
+     *   await tx.create('feature_flag_evaluations', {
+     *     flag_key: 'BULK_UPDATE',
+     *     result: { updatedFlags: flagsToUpdate },
+     *     reason: 'bulk_disable',
+     *     evaluated_at: new Date().toISOString()
+     *   });
+     * });
+     * ```
+     *
+     * @example Error Handling and Rollback
+     * ```typescript
+     * try {
+     *   await manager.transaction(async (tx) => {
+     *     await tx.create('feature_flags', { key: 'TEST_FLAG', value: true });
+     *
+     *     // This will cause the entire transaction to rollback
+     *     throw new Error('Something went wrong');
+     *
+     *     // This won't execute, and the flag creation above will be rolled back
+     *     await tx.create('feature_flag_rules', { flag_key: 'TEST_FLAG' });
+     *   });
+     * } catch (error) {
+     *   console.log('Transaction failed, all changes rolled back');
+     * }
+     * ```
+     */
+    transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+    /**
+     * Closes the database connection and cleans up resources
+     *
+     * @description Properly closes the database connection and resets the singleton instance.
+     * This is typically called during application shutdown or in tests that need to reset
+     * the connection state.
+     *
+     * @example Application Shutdown
+     * ```typescript
+     * // In your NestJS module's onModuleDestroy
+     * export class FeatureFlagModule implements OnModuleDestroy {
+     *   async onModuleDestroy() {
+     *     const manager = DatabaseConnectionManager.getInstance();
+     *     await manager.close();
+     *     console.log('Database connection closed');
+     *   }
+     * }
+     * ```
+     *
+     * @example Test Cleanup
+     * ```typescript
+     * describe('Feature Flag Tests', () => {
+     *   afterEach(async () => {
+     *     // Clean up connection between tests
+     *     const manager = DatabaseConnectionManager.getInstance();
+     *     await manager.close();
+     *   });
+     * });
+     * ```
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=connection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/database/connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,wBAAwB,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA4B;IACnD,OAAO,CAAC,eAAe,CAAyC;IAEhE,OAAO;IAEP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,WAAW,IAAI,yBAAyB;IAO/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA4DjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,WAAW,IAAI,wBAAwB;IAUvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiFG;IACG,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAe3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B"}