@plyaz/core 1.1.1 → 1.2.1

package/dist/models/featureFlags/FeatureFlagRepository.d.ts

@@ -0,0 +1,560 @@
+/**
+ * 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';
+import { type CoreFeatureFlagTableConfig } from '@plyaz/types/core';
+/**
+ * Database Repository for Feature Flags
+ *
+ * **FOURTH COMPONENT CALLED** - Handles all database operations for feature flags
+ *
+ * **EXECUTION ORDER:**
+ * 1. FeatureFlagService.onModuleInit()
+ * 2. → FeatureFlagConfigFactory.fromOptions()
+ * 3. → DbService.initialize()
+ * 4. → **THIS REPOSITORY USED** ← YOU ARE HERE
+ * 5. → Database queries executed via @plyaz/db
+ *
+ * **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 readonly tableConfig;
+    /**
+     * Creates a new repository with optional custom table names.
+     *
+     * @param tableConfig - Optional custom table configuration
+     *
+     * @example Default tables
+     * ```typescript
+     * const repo = new FeatureFlagDatabaseRepository();
+     * // Uses: feature_flags, feature_flag_rules, feature_flag_evaluations, feature_flag_overrides
+     * ```
+     *
+     * @example Custom test tables
+     * ```typescript
+     * const repo = new FeatureFlagDatabaseRepository({
+     *   flagsTable: 'test_feature_flags',
+     *   rulesTable: 'test_feature_flag_rules',
+     *   evaluationsTable: 'test_feature_flag_evaluations',
+     *   overridesTable: 'test_feature_flag_overrides',
+     *   evaluationsSchema: 'audit',
+     * });
+     * ```
+     */
+    constructor(tableConfig?: Partial<CoreFeatureFlagTableConfig>);
+    /**
+     * Gets the current table configuration.
+     */
+    getTableConfig(): CoreFeatureFlagTableConfig;
+    /**
+     * Gets the full table name including schema if needed.
+     */
+    private getEvaluationsTableName;
+    /**
+     * Gets the database service from DbService singleton
+     */
+    private getDb;
+    /**
+     * 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>>;
+    /**
+     * Infers the type of a given value as a string for the type field
+     * @param value Unknown value
+     * @returns Inferred type as string
+     */
+    private toTypeField;
+    /**
+     * 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=FeatureFlagRepository.d.ts.map

package/dist/models/featureFlags/FeatureFlagRepository.d.ts.map

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

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

@@ -0,0 +1,7 @@
+/**
+ * Feature Flags Models/Repositories
+ *
+ * Data access layer for feature flags.
+ */
+export { FeatureFlagDatabaseRepository } from './FeatureFlagRepository';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/featureFlags/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/models/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Models/Repositories
+ *
+ * Centralized data access layer organized by domain.
+ * Repositories use DbService when initialized, fall back to dummy data otherwise.
+ */
+export * from './example';
+export * from './featureFlags';
+//# sourceMappingURL=index.d.ts.map

package/dist/models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}