@plyaz/core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,3902 @@
+import { FEATURES } from '@plyaz/config';
+import { Post, Param, Body, Put, Delete, Get, Query, Controller, Injectable, Global, Module, HttpException, HttpStatus, Logger } from '@nestjs/common';
+import React, { createContext, useState, useRef, useCallback, useEffect, useContext, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// @plyaz package - Built with tsup
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+
+// src/utils/common/hash.ts
+function hashString(str) {
+  const HASH_SHIFT = 5;
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << HASH_SHIFT) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+__name(hashString, "hashString");
+function isInRollout(identifier, percentage) {
+  if (percentage >= 100) return true;
+  if (percentage <= 0) return false;
+  const hash = hashString(identifier);
+  return hash % 100 < percentage;
+}
+__name(isInRollout, "isInRollout");
+function createRolloutIdentifier(featureKey, userId) {
+  const trimmedUserId = userId?.trim();
+  const effectiveUserId = trimmedUserId && trimmedUserId.length > 0 ? trimmedUserId : "anonymous";
+  return `${featureKey}:${effectiveUserId}`;
+}
+__name(createRolloutIdentifier, "createRolloutIdentifier");
+var HashUtils = {
+  /**
+   * Generates a hash-based bucket for load balancing or distribution.
+   *
+   * @param identifier - Unique identifier
+   * @param bucketCount - Number of buckets (default: 10)
+   * @returns Bucket number (0 to bucketCount-1)
+   */
+  getBucket: /* @__PURE__ */ __name((identifier, bucketCount = 10) => {
+    return hashString(identifier) % bucketCount;
+  }, "getBucket"),
+  /**
+   * Checks if an identifier falls within a specific bucket range.
+   *
+   * @param identifier - Unique identifier
+   * @param startBucket - Starting bucket (inclusive)
+   * @param endBucket - Ending bucket (inclusive)
+   * @param totalBuckets - Total number of buckets (default: 100)
+   * @returns true if identifier is in the bucket range
+   */
+  isInBucketRange: /* @__PURE__ */ __name((identifier, startBucket, endBucket, totalBuckets = 100) => {
+    const bucket = hashString(identifier) % totalBuckets;
+    return bucket >= startBucket && bucket <= endBucket;
+  }, "isInBucketRange"),
+  /**
+   * Creates a deterministic random seed from a string.
+   *
+   * @param str - String to convert to seed
+   * @returns Deterministic seed value
+   */
+  createSeed: /* @__PURE__ */ __name((str) => {
+    const SAFE_INT = 2147483647;
+    return hashString(str) % SAFE_INT;
+  }, "createSeed")
+};
+
+// src/utils/common/values.ts
+function isStringFalsy(value) {
+  if (value === "") return true;
+  const lower = value.toLowerCase().trim();
+  return ["false", "no", "0", "off", "disabled"].includes(lower);
+}
+__name(isStringFalsy, "isStringFalsy");
+function isObjectTruthy(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  if (value instanceof Map || value instanceof Set) return value.size > 0;
+  if (value.constructor === Object) return Object.keys(value).length > 0;
+  return true;
+}
+__name(isObjectTruthy, "isObjectTruthy");
+function isTruthy(value) {
+  if (value === null || value === void 0) return false;
+  switch (typeof value) {
+    case "boolean":
+      return value;
+    case "string":
+      return !isStringFalsy(value);
+    case "number":
+      return value !== 0 && !isNaN(value);
+    case "function":
+    case "symbol":
+      return true;
+    case "object":
+      return isObjectTruthy(value);
+    default:
+      return false;
+  }
+}
+__name(isTruthy, "isTruthy");
+function parseStringToBoolean(value, defaultValue) {
+  const lower = value.toLowerCase();
+  if (["true", "yes", "1", "on", "enabled"].includes(lower)) return true;
+  if (["false", "no", "0", "off", "disabled"].includes(lower)) return false;
+  return defaultValue;
+}
+__name(parseStringToBoolean, "parseStringToBoolean");
+function toBoolean(value, defaultValue = false) {
+  if (value === null || value === void 0) return false;
+  switch (typeof value) {
+    case "boolean":
+      return value;
+    case "string":
+      return parseStringToBoolean(value, defaultValue);
+    case "number":
+      return value !== 0 && !isNaN(value);
+    case "object":
+    case "function":
+      return true;
+    default:
+      return defaultValue;
+  }
+}
+__name(toBoolean, "toBoolean");
+var ValueUtils = {
+  /**
+   * Checks if a value is a valid percentage (0-100).
+   *
+   * @param value - Value to check
+   * @returns true if valid percentage
+   */
+  isValidPercentage: /* @__PURE__ */ __name((value) => {
+    if (typeof value !== "number") return false;
+    return !isNaN(value) && isFinite(value) && value >= 0 && value <= 100;
+  }, "isValidPercentage"),
+  /**
+   * Clamps a number to a specific range.
+   *
+   * @param value - Value to clamp
+   * @param min - Minimum value
+   * @param max - Maximum value
+   * @returns Clamped value
+   */
+  clamp: /* @__PURE__ */ __name((value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+  }, "clamp"),
+  /**
+   * Checks if a value is empty (null, undefined, empty string, empty array).
+   *
+   * @param value - Value to check
+   * @returns true if empty
+   */
+  isEmpty: /* @__PURE__ */ __name((value) => {
+    if (value === null || value === void 0) return true;
+    if (typeof value === "string") return value.trim() === "";
+    if (Array.isArray(value)) return value.length === 0;
+    if (typeof value === "object") return Object.keys(value).length === 0;
+    return false;
+  }, "isEmpty"),
+  /**
+   * Safely gets a nested property from an object.
+   *
+   * @param obj - Object to query
+   * @param path - Dot-separated path (e.g., 'user.profile.name')
+   * @param defaultValue - Default if path doesn't exist
+   * @returns Property value or default
+   */
+  getNestedProperty: /* @__PURE__ */ __name((obj, path, defaultValue) => {
+    if (!obj || typeof obj !== "object") return defaultValue;
+    const keys = path.split(".");
+    let current = obj;
+    for (const key of keys) {
+      if (current == null || typeof current !== "object") return defaultValue;
+      current = current[key];
+      if (current === void 0) return defaultValue;
+    }
+    return current;
+  }, "getNestedProperty")
+};
+
+// src/utils/featureFlags/context.ts
+var FeatureFlagContextBuilder = class _FeatureFlagContextBuilder {
+  static {
+    __name(this, "FeatureFlagContextBuilder");
+  }
+  context = {};
+  /**
+   * Sets the user ID in the context.
+   *
+   * @param userId - User identifier
+   * @returns Builder instance for chaining
+   */
+  setUserId(userId) {
+    this.context.userId = userId;
+    return this;
+  }
+  /**
+   * Sets the user email in the context.
+   *
+   * @param userEmail - User email address
+   * @returns Builder instance for chaining
+   */
+  setUserEmail(userEmail) {
+    this.context.userEmail = userEmail;
+    return this;
+  }
+  /**
+   * Sets the user role in the context.
+   *
+   * @param userRole - User role or permission level
+   * @returns Builder instance for chaining
+   */
+  setUserRole(userRole) {
+    this.context.userRole = userRole;
+    return this;
+  }
+  /**
+   * Sets the country in the context.
+   *
+   * @param country - Country code (ISO 3166-1 alpha-2)
+   * @returns Builder instance for chaining
+   */
+  setCountry(country) {
+    this.context.country = country;
+    return this;
+  }
+  /**
+   * Sets the platform in the context.
+   *
+   * @param platform - Platform type
+   * @returns Builder instance for chaining
+   */
+  setPlatform(platform) {
+    this.context.platform = platform;
+    return this;
+  }
+  /**
+   * Sets the version in the context.
+   *
+   * @param version - Application version
+   * @returns Builder instance for chaining
+   */
+  setVersion(version) {
+    this.context.version = version;
+    return this;
+  }
+  /**
+   * Sets the environment in the context.
+   *
+   * @param environment - Current environment
+   * @returns Builder instance for chaining
+   */
+  setEnvironment(environment) {
+    this.context.environment = environment;
+    return this;
+  }
+  /**
+   * Sets custom context data.
+   *
+   * @param custom - Custom context properties
+   * @returns Builder instance for chaining
+   */
+  setCustom(custom) {
+    this.context.custom = { ...this.context.custom, ...custom };
+    return this;
+  }
+  /**
+   * Adds a single custom property to the context.
+   *
+   * @param key - Custom property key
+   * @param value - Custom property value
+   * @returns Builder instance for chaining
+   */
+  addCustomProperty(key, value) {
+    this.context.custom ??= {};
+    this.context.custom[key] = value;
+    return this;
+  }
+  /**
+   * Builds the final context object.
+   * Validates required fields and returns the context.
+   *
+   * @returns Complete feature flag context
+   * @throws Error if required environment is not set
+   */
+  build() {
+    return {
+      environment: this.context.environment ?? "development",
+      userId: this.context.userId,
+      userEmail: this.context.userEmail,
+      userRole: this.context.userRole,
+      country: this.context.country,
+      platform: this.context.platform,
+      version: this.context.version,
+      custom: this.context.custom
+    };
+  }
+  /**
+   * Clears all context data and resets the builder.
+   *
+   * @returns Builder instance for chaining
+   */
+  clear() {
+    this.context = {};
+    return this;
+  }
+  /**
+   * Creates a copy of the current builder state.
+   *
+   * @returns New builder instance with copied context
+   */
+  clone() {
+    const cloned = new _FeatureFlagContextBuilder();
+    cloned.context = { ...this.context };
+    if (this.context.custom) {
+      cloned.context.custom = { ...this.context.custom };
+    }
+    return cloned;
+  }
+};
+var ContextUtils = {
+  /**
+   * Creates a basic context for anonymous users using the builder.
+   *
+   * @param environment - Target environment
+   * @param platform - User platform
+   * @returns Basic anonymous context
+   */
+  createAnonymousContext(environment, platform = "web") {
+    return new FeatureFlagContextBuilder().setEnvironment(environment).setPlatform(platform).build();
+  },
+  /**
+   * Creates a context for authenticated users using the builder.
+   *
+   * @param params - User context parameters
+   * @returns User context
+   */
+  createUserContext(params) {
+    const builder = new FeatureFlagContextBuilder().setUserId(params.userId).setEnvironment(params.environment);
+    if (params.userEmail) builder.setUserEmail(params.userEmail);
+    if (params.userRole) builder.setUserRole(params.userRole);
+    if (params.platform) builder.setPlatform(params.platform);
+    if (params.country) builder.setCountry(params.country);
+    if (params.version) builder.setVersion(params.version);
+    if (params.custom) builder.setCustom(params.custom);
+    return builder.build();
+  },
+  /**
+   * Creates a testing context with minimal required fields.
+   *
+   * @param overrides - Optional context overrides
+   * @returns Testing context
+   */
+  createTestingContext(overrides = {}) {
+    return {
+      environment: "development",
+      platform: "web",
+      ...overrides
+    };
+  },
+  /**
+   * Validates if a context object is complete and valid.
+   *
+   * @param context - Context to validate
+   * @returns Validation result
+   */
+  validateContext(context) {
+    const errors = [];
+    if (!context.environment) {
+      errors.push("Environment is required");
+    } else if (!["development", "staging", "production"].includes(context.environment)) {
+      errors.push("Environment must be development, staging, or production");
+    }
+    if (context.platform && !["web", "mobile", "desktop"].includes(context.platform)) {
+      errors.push("Platform must be web, mobile, or desktop");
+    }
+    if (context.country && context.country.length !== 2) {
+      errors.push("Country must be a 2-letter ISO country code");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  },
+  /**
+   * Merges multiple context objects, with later contexts taking precedence.
+   *
+   * @param contexts - Array of contexts to merge
+   * @returns Merged context
+   */
+  mergeContexts(...contexts) {
+    const merged = contexts.reduce((acc, context) => {
+      const result = {
+        ...acc,
+        ...context
+      };
+      if (acc.custom || context.custom) {
+        result.custom = {
+          ...acc.custom,
+          ...context.custom
+        };
+      }
+      return result;
+    }, {});
+    merged.environment ??= "development";
+    return merged;
+  },
+  /**
+   * Extracts a specific field value from a context.
+   *
+   * @param field - Field name to extract
+   * @param context - Context object
+   * @returns Field value or undefined
+   */
+  getContextValue(field, context) {
+    const standardFields = {
+      userId: /* @__PURE__ */ __name((ctx) => ctx.userId, "userId"),
+      userEmail: /* @__PURE__ */ __name((ctx) => ctx.userEmail, "userEmail"),
+      userRole: /* @__PURE__ */ __name((ctx) => ctx.userRole, "userRole"),
+      country: /* @__PURE__ */ __name((ctx) => ctx.country, "country"),
+      platform: /* @__PURE__ */ __name((ctx) => ctx.platform, "platform"),
+      version: /* @__PURE__ */ __name((ctx) => ctx.version, "version"),
+      environment: /* @__PURE__ */ __name((ctx) => ctx.environment, "environment"),
+      custom: /* @__PURE__ */ __name((ctx) => ctx.custom, "custom")
+    };
+    if (field in standardFields) {
+      return standardFields[field](context);
+    }
+    return context.custom?.[field];
+  },
+  /**
+   * Creates a context fingerprint for caching and consistency.
+   *
+   * @param context - Context to fingerprint
+   * @returns String fingerprint
+   */
+  createFingerprint(context) {
+    const relevant = {
+      userId: context.userId,
+      userRole: context.userRole,
+      environment: context.environment,
+      platform: context.platform,
+      country: context.country,
+      version: context.version,
+      custom: context.custom
+    };
+    const filtered = Object.entries(relevant).filter(([, value]) => value !== void 0).sort(([a], [b]) => a.localeCompare(b)).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    return JSON.stringify(filtered);
+  },
+  /**
+   * Sanitizes a context by removing sensitive information.
+   *
+   * @param context - Context to sanitize
+   * @param sensitiveFields - Fields to remove (default: ['userEmail'])
+   * @returns Sanitized context
+   */
+  sanitizeContext(context, sensitiveFields = ["userEmail"]) {
+    const sanitized = { ...context };
+    if (context.custom) {
+      sanitized.custom = { ...context.custom };
+    }
+    for (const field of sensitiveFields) {
+      if (field in sanitized) {
+        delete sanitized[field];
+      }
+      if (sanitized.custom && field in sanitized.custom) {
+        delete sanitized.custom[field];
+      }
+    }
+    return sanitized;
+  }
+};
+function createBackendContext(params) {
+  return {
+    environment: params.environment,
+    userId: params.userId,
+    userEmail: params.userEmail,
+    userRole: params.userRole,
+    platform: params.platform ?? "api",
+    country: params.country,
+    version: params.version,
+    custom: params.custom
+  };
+}
+__name(createBackendContext, "createBackendContext");
+function createFrontendContext(params) {
+  return {
+    environment: params.environment,
+    userId: params.userId,
+    userEmail: params.userEmail,
+    userRole: params.userRole,
+    platform: params.platform ?? "web",
+    country: params.country,
+    version: params.version,
+    custom: params.custom
+  };
+}
+__name(createFrontendContext, "createFrontendContext");
+
+// src/utils/featureFlags/conditions.ts
+function evaluateConditionOperator(condition, contextValue) {
+  const { operator } = condition;
+  if (isEqualityOperator(operator)) {
+    return evaluateEqualityOperator(operator, contextValue, condition.value);
+  }
+  if (isStringOperator(operator)) {
+    return evaluateStringOperator(operator, contextValue, condition.value);
+  }
+  if (isArrayOperator(operator)) {
+    return evaluateArrayOperator(operator, condition.value, contextValue);
+  }
+  if (isNumericOperator(operator)) {
+    return evaluateNumericOperator(operator, contextValue, condition.value);
+  }
+  return false;
+}
+__name(evaluateConditionOperator, "evaluateConditionOperator");
+function isEqualityOperator(operator) {
+  return operator === "equals" || operator === "not_equals";
+}
+__name(isEqualityOperator, "isEqualityOperator");
+function isStringOperator(operator) {
+  return operator === "contains" || operator === "not_contains";
+}
+__name(isStringOperator, "isStringOperator");
+function isArrayOperator(operator) {
+  return operator === "in" || operator === "not_in";
+}
+__name(isArrayOperator, "isArrayOperator");
+function isNumericOperator(operator) {
+  return operator === "greater_than" || operator === "less_than";
+}
+__name(isNumericOperator, "isNumericOperator");
+function evaluateEqualityOperator(operator, contextValue, conditionValue) {
+  const isEqual = contextValue === conditionValue;
+  return operator === "equals" ? isEqual : !isEqual;
+}
+__name(evaluateEqualityOperator, "evaluateEqualityOperator");
+function evaluateStringOperator(operator, contextValue, conditionValue) {
+  if (typeof contextValue === "string" && typeof conditionValue === "string") {
+    const contains = contextValue.includes(conditionValue);
+    return operator === "contains" ? contains : !contains;
+  }
+  if (Array.isArray(contextValue) && typeof conditionValue === "string") {
+    const contains = contextValue.includes(conditionValue);
+    return operator === "contains" ? contains : !contains;
+  }
+  return operator === "not_contains";
+}
+__name(evaluateStringOperator, "evaluateStringOperator");
+function evaluateArrayOperator(operator, conditionValue, contextValue) {
+  if (!Array.isArray(conditionValue)) {
+    return operator === "not_in";
+  }
+  const isIncluded = conditionValue.includes(contextValue);
+  return operator === "in" ? isIncluded : !isIncluded;
+}
+__name(evaluateArrayOperator, "evaluateArrayOperator");
+function compareValues(operator, left, right) {
+  switch (operator) {
+    case "greater_than":
+      return left > right;
+    case "less_than":
+      return left < right;
+    default:
+      return false;
+  }
+}
+__name(compareValues, "compareValues");
+function evaluateNumericOperator(operator, contextValue, conditionValue) {
+  const contextNum = Number(contextValue);
+  const conditionNum = Number(conditionValue);
+  if (!isNaN(contextNum) && !isNaN(conditionNum)) {
+    return compareValues(operator, contextNum, conditionNum);
+  }
+  if (typeof contextValue === "string" && typeof conditionValue === "string") {
+    return compareValues(operator, contextValue, conditionValue);
+  }
+  return false;
+}
+__name(evaluateNumericOperator, "evaluateNumericOperator");
+var ConditionUtils = {
+  /**
+   * Evaluates multiple conditions with AND logic.
+   *
+   * @param conditions - Array of conditions
+   * @param contextValue - Context value getter function
+   * @returns true if all conditions match
+   */
+  evaluateConditionsAnd: /* @__PURE__ */ __name((conditions, contextValue) => {
+    if (conditions.length === 0) return true;
+    return conditions.every((condition) => {
+      const value = contextValue(condition.field);
+      if (value === void 0) return false;
+      return evaluateConditionOperator(condition, value);
+    });
+  }, "evaluateConditionsAnd"),
+  /**
+   * Evaluates multiple conditions with OR logic.
+   *
+   * @param conditions - Array of conditions
+   * @param contextValue - Context value getter function
+   * @returns true if any condition matches
+   */
+  evaluateConditionsOr: /* @__PURE__ */ __name((conditions, contextValue) => {
+    if (conditions.length === 0) return true;
+    return conditions.some((condition) => {
+      const value = contextValue(condition.field);
+      if (value === void 0) return false;
+      return evaluateConditionOperator(condition, value);
+    });
+  }, "evaluateConditionsOr"),
+  /**
+   * Validates a condition structure.
+   *
+   * @param condition - Condition to validate
+   * @returns Validation result
+   */
+  validateCondition: /* @__PURE__ */ __name((condition) => {
+    const errors = [];
+    if (!condition.field) {
+      errors.push("Field is required");
+    }
+    if (!condition.operator) {
+      errors.push("Operator is required");
+    } else {
+      const validOperators = [
+        "equals",
+        "not_equals",
+        "contains",
+        "not_contains",
+        "in",
+        "not_in",
+        "greater_than",
+        "less_than"
+      ];
+      if (!validOperators.includes(condition.operator)) {
+        errors.push(`Invalid operator: ${condition.operator}`);
+      }
+    }
+    if (condition.value === void 0) {
+      errors.push("Value is required");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }, "validateCondition"),
+  /**
+   * Creates a condition object with validation.
+   *
+   * @param field - Context field to evaluate
+   * @param operator - Comparison operator
+   * @param value - Value to compare against
+   * @returns Valid condition object
+   */
+  createCondition: /* @__PURE__ */ __name((field, operator, value) => {
+    const condition = { field, operator, value };
+    const validation = ConditionUtils.validateCondition(condition);
+    if (!validation.isValid) {
+      throw new Error(`Invalid condition: ${validation.errors.join(", ")}`);
+    }
+    return condition;
+  }, "createCondition")
+};
+
+// src/engine/featureFlags/engine.ts
+var FeatureFlagEngine = class {
+  /**
+   * Creates a new feature flag evaluation engine.
+   *
+   * @param defaults - Default flag values to fall back to
+   * @param isLoggingEnabled - Whether to enable debug logging
+   */
+  constructor(defaults, isLoggingEnabled = false) {
+    this.defaults = defaults;
+    this.isLoggingEnabled = isLoggingEnabled;
+  }
+  static {
+    __name(this, "FeatureFlagEngine");
+  }
+  /** Storage for active feature flags */
+  flags = /* @__PURE__ */ new Map();
+  /** Storage for targeting rules, organized by flag key */
+  rules = /* @__PURE__ */ new Map();
+  /** Storage for manual overrides (useful for testing) */
+  overrides = /* @__PURE__ */ new Map();
+  /**
+   * Sets the active feature flags for evaluation.
+   * Clears existing flags and rules before setting new ones.
+   *
+   * @param flags - Array of feature flags to activate
+   */
+  setFlags(flags) {
+    this.flags.clear();
+    this.rules.clear();
+    for (const flag of flags) {
+      this.flags.set(flag.key, flag);
+    }
+    this.log("Loaded flags:", this.flags.size);
+  }
+  /**
+   * Sets the targeting rules for feature flags.
+   * Rules are automatically sorted by priority (higher numbers first).
+   *
+   * @param rules - Array of feature flag rules
+   */
+  setRules(rules) {
+    this.rules.clear();
+    for (const rule of rules) {
+      const existing = this.rules.get(rule.flagKey) ?? [];
+      existing.push(rule);
+      existing.sort((a, b) => b.priority - a.priority);
+      this.rules.set(rule.flagKey, existing);
+    }
+    this.log("Loaded rules:", rules.length);
+  }
+  /**
+   * Sets a manual override for a specific flag.
+   * Overrides take precedence over all other evaluation logic.
+   *
+   * @param key - The flag key to override
+   * @param value - The value to force for this flag
+   */
+  setOverride(key, value) {
+    this.overrides.set(key, value);
+    this.log("Override set:", key, value);
+  }
+  /**
+   * Removes a manual override for a specific flag.
+   *
+   * @param key - The flag key to remove override for
+   */
+  removeOverride(key) {
+    this.overrides.delete(key);
+    this.log("Override removed:", key);
+  }
+  /**
+   * Clears all manual overrides.
+   */
+  clearOverrides() {
+    this.overrides.clear();
+    this.log("All overrides cleared");
+  }
+  /**
+   * Gets all current flags.
+   *
+   * @returns Array of all feature flags
+   */
+  getFlags() {
+    return Array.from(this.flags.values());
+  }
+  /**
+   * Evaluates a feature flag and returns the complete evaluation result.
+   *
+   * @param key - The feature flag key to evaluate
+   * @param context - Optional context for targeting
+   * @returns Complete evaluation result with value and metadata
+   */
+  evaluate(key, context) {
+    const evaluatedAt = /* @__PURE__ */ new Date();
+    const overrideResult = this.checkOverride(key, evaluatedAt);
+    if (overrideResult) return overrideResult;
+    const flag = this.flags.get(key);
+    if (!flag) {
+      return this.createDefaultEvaluation(key, evaluatedAt);
+    }
+    if (!flag.isEnabled) {
+      return this.createDisabledEvaluation(key, evaluatedAt);
+    }
+    if (!this.isEnvironmentMatch(flag, context)) {
+      return this.createDefaultEvaluation(key, evaluatedAt);
+    }
+    const ruleResult = this.evaluateRules(key, context, evaluatedAt);
+    if (ruleResult) return ruleResult;
+    if (!this.isInFlagRollout(key, flag, context)) {
+      return this.createDefaultEvaluation(key, evaluatedAt);
+    }
+    return this.createFlagEvaluation(key, flag, evaluatedAt);
+  }
+  /**
+   * Checks for manual override and returns evaluation if found.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param evaluatedAt - Evaluation timestamp
+   * @returns Evaluation result or null if no override
+   */
+  checkOverride(key, evaluatedAt) {
+    if (!this.overrides.has(key)) return null;
+    const value = this.overrides.get(key);
+    return {
+      flagKey: key,
+      value,
+      isEnabled: isTruthy(value),
+      reason: "override",
+      evaluatedAt
+    };
+  }
+  /**
+   * Creates default evaluation result.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param evaluatedAt - Evaluation timestamp
+   * @returns Default evaluation result
+   */
+  createDefaultEvaluation(key, evaluatedAt) {
+    const defaultValue = this.defaults[key] ?? false;
+    return {
+      flagKey: key,
+      value: defaultValue,
+      isEnabled: isTruthy(defaultValue),
+      reason: "default",
+      evaluatedAt
+    };
+  }
+  /**
+   * Creates disabled evaluation result.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param evaluatedAt - Evaluation timestamp
+   * @returns Disabled evaluation result
+   */
+  createDisabledEvaluation(key, evaluatedAt) {
+    return {
+      flagKey: key,
+      value: false,
+      isEnabled: false,
+      reason: "disabled",
+      evaluatedAt
+    };
+  }
+  /**
+   * Creates flag evaluation result.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param flag - The feature flag
+   * @param evaluatedAt - Evaluation timestamp
+   * @returns Flag evaluation result
+   */
+  createFlagEvaluation(key, flag, evaluatedAt) {
+    return {
+      flagKey: key,
+      value: flag.value,
+      isEnabled: isTruthy(flag.value),
+      reason: "default",
+      evaluatedAt
+    };
+  }
+  /**
+   * Checks if environment matches for flag evaluation.
+   *
+   * @private
+   * @param flag - The feature flag
+   * @param context - Evaluation context
+   * @returns true if environment matches
+   */
+  isEnvironmentMatch(flag, context) {
+    return flag.environment === "all" || context?.environment === flag.environment;
+  }
+  /**
+   * Checks if user is in flag-level rollout.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param flag - The feature flag
+   * @param context - Evaluation context
+   * @returns true if user is in rollout
+   */
+  isInFlagRollout(key, flag, context) {
+    if (flag.rolloutPercentage === void 0) return true;
+    const identifier = createRolloutIdentifier(key, context?.userId);
+    return isInRollout(identifier, flag.rolloutPercentage);
+  }
+  /**
+   * Evaluates all rules for a flag.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param context - Evaluation context
+   * @param evaluatedAt - Evaluation timestamp
+   * @returns Rule evaluation result or null if no match
+   */
+  evaluateRules(key, context, evaluatedAt) {
+    const rules = this.rules.get(key) ?? [];
+    for (const rule of rules) {
+      if (!rule.isEnabled) continue;
+      const ruleResult = this.evaluateMatchingRule(key, rule, context, evaluatedAt);
+      if (ruleResult) return ruleResult;
+    }
+    return null;
+  }
+  /**
+   * Evaluates a single matching rule and returns result if it passes.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param rule - The rule to evaluate
+   * @param context - Evaluation context
+   * @param evaluatedAt - Evaluation timestamp
+   * @returns Rule evaluation result or null if no match
+   */
+  evaluateMatchingRule(key, rule, context, evaluatedAt) {
+    if (!this.evaluateRule(rule, context)) return null;
+    const isInRuleRollout = rule.rolloutPercentage === void 0 || isInRollout(createRolloutIdentifier(key, context?.userId), rule.rolloutPercentage);
+    if (!isInRuleRollout) return null;
+    return {
+      flagKey: key,
+      value: rule.value,
+      isEnabled: isTruthy(rule.value),
+      reason: "rule_match",
+      ruleId: rule.id,
+      evaluatedAt: evaluatedAt ?? /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Evaluates a single rule against the provided context.
+   * All conditions in the rule must match (AND logic).
+   *
+   * @private
+   * @param rule - The rule to evaluate
+   * @param context - Context to evaluate against
+   * @returns true if the rule matches the context
+   */
+  evaluateRule(rule, context) {
+    if (rule.conditions.length === 0) return true;
+    return rule.conditions.every((condition) => this.evaluateCondition(condition, context));
+  }
+  /**
+   * Evaluates a single condition against the provided context.
+   *
+   * @private
+   * @param condition - The condition to evaluate
+   * @param context - Context to evaluate against
+   * @returns true if the condition matches
+   */
+  evaluateCondition(condition, context) {
+    if (!context) return false;
+    const contextValue = ContextUtils.getContextValue(condition.field, context);
+    if (contextValue === void 0) return false;
+    return evaluateConditionOperator(condition, contextValue);
+  }
+  /**
+   * Logs debug information if logging is enabled.
+   *
+   * @private
+   * @param args - Arguments to log
+   */
+  log(...args) {
+    if (this.isLoggingEnabled) {
+      console.log("[FeatureFlagEngine]", ...args);
+    }
+  }
+};
+
+// src/cache/strategies/memory.ts
+var MemoryCacheStrategy = class {
+  static {
+    __name(this, "MemoryCacheStrategy");
+  }
+  cache = /* @__PURE__ */ new Map();
+  accessOrder = /* @__PURE__ */ new Map();
+  stats = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+    deletes: 0
+  };
+  cleanupTimer;
+  maxSize;
+  cleanupInterval;
+  onEvict;
+  /**
+   * Creates a new memory cache strategy.
+   *
+   * @param config - Memory cache configuration
+   */
+  constructor(config = {}) {
+    const DEFAULT_MAX_ENTRIES = 1e3;
+    const DEFAULT_CLEANUP_INTERVAL = 6e4;
+    const defaultConfig = {
+      maxEntries: DEFAULT_MAX_ENTRIES,
+      cleanupInterval: DEFAULT_CLEANUP_INTERVAL
+    };
+    this.maxSize = config.maxSize ?? config.maxEntries ?? defaultConfig.maxEntries;
+    this.cleanupInterval = config.cleanupInterval ?? defaultConfig.cleanupInterval;
+    this.onEvict = config.onEvict;
+    this.startCleanup();
+  }
+  /**
+   * Stores a cache entry in memory.
+   *
+   * @param key - Cache key
+   * @param entry - Cache entry to store
+   * @returns Promise that resolves when entry is stored
+   */
+  async set(key, entry) {
+    if (this.maxSize === 0) {
+      this.stats.sets++;
+      return;
+    }
+    if (!this.cache.has(key) && this.cache.size >= this.maxSize) {
+      this.evictOldestEntries();
+    }
+    this.cache.set(key, entry);
+    this.accessOrder.set(key, Date.now());
+    this.stats.sets++;
+  }
+  /**
+   * Retrieves a cache entry from memory.
+   *
+   * @param key - Cache key
+   * @returns Promise that resolves to cache entry or null if not found
+   */
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return null;
+    }
+    this.accessOrder.set(key, Date.now());
+    this.stats.hits++;
+    return entry;
+  }
+  /**
+   * Removes a cache entry from memory.
+   *
+   * @param key - Cache key to remove
+   * @returns Promise that resolves when entry is removed
+   */
+  async delete(key) {
+    this.cache.delete(key);
+    this.accessOrder.delete(key);
+    this.stats.deletes++;
+  }
+  /**
+   * Clears all cache entries from memory.
+   *
+   * @returns Promise that resolves when cache is cleared
+   */
+  async clear() {
+    this.cache.clear();
+    this.accessOrder.clear();
+    this.stats.hits = 0;
+    this.stats.misses = 0;
+    this.stats.sets = 0;
+    this.stats.deletes = 0;
+  }
+  /**
+   * Gets cache statistics.
+   *
+   * @returns Promise that resolves to cache statistics
+   */
+  async getStats() {
+    const totalRequests = this.stats.hits + this.stats.misses;
+    const hitRatio = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+    return {
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      sets: this.stats.sets,
+      deletes: this.stats.deletes,
+      size: this.cache.size,
+      hitRatio
+    };
+  }
+  /**
+   * Disposes of the memory cache and cleans up resources.
+   *
+   * @returns Promise that resolves when cleanup is complete
+   */
+  async dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    await this.clear();
+  }
+  /**
+   * Starts the periodic cleanup of expired entries.
+   *
+   * @private
+   */
+  startCleanup() {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupExpiredEntries();
+    }, this.cleanupInterval);
+  }
+  /**
+   * Removes expired entries from the cache.
+   *
+   * @private
+   */
+  cleanupExpiredEntries() {
+    const now = Date.now();
+    const expiredKeys = [];
+    for (const [key, entry] of Array.from(this.cache.entries())) {
+      if (now > entry.expiresAt) {
+        expiredKeys.push(key);
+      }
+    }
+    for (const key of expiredKeys) {
+      const entry = this.cache.get(key);
+      this.cache.delete(key);
+      this.accessOrder.delete(key);
+      if (entry && this.onEvict) {
+        this.onEvict(key, entry);
+      }
+    }
+  }
+  /**
+   * Evicts the oldest entries when cache is full.
+   * Uses LRU-like eviction by removing the oldest entries by creation time.
+   *
+   * @private
+   */
+  evictOldestEntries() {
+    if (this.maxSize === 0) {
+      this.cache.clear();
+      this.accessOrder.clear();
+      return;
+    }
+    const EVICTION_PERCENTAGE = 0.1;
+    const entriesToEvict = Math.max(1, Math.ceil(this.maxSize * EVICTION_PERCENTAGE));
+    const sortedEntries = Array.from(this.accessOrder.entries()).sort(([, timeA], [, timeB]) => timeA - timeB).slice(0, entriesToEvict);
+    for (const [key] of sortedEntries) {
+      const entry = this.cache.get(key);
+      this.cache.delete(key);
+      this.accessOrder.delete(key);
+      if (entry && this.onEvict) {
+        this.onEvict(key, entry);
+      }
+    }
+  }
+};
+
+// src/cache/strategies/redis.ts
+var RedisCacheStrategy = class {
+  /**
+   * Creates a new Redis cache strategy.
+   *
+   * @param config - Redis cache configuration
+   */
+  constructor(config) {
+    this.config = config;
+    if (!config.url) {
+      throw new Error("Redis URL is required");
+    }
+    this.keyPrefix = config.keyPrefix ?? "cache:";
+  }
+  static {
+    __name(this, "RedisCacheStrategy");
+  }
+  client;
+  stats = {
+    hitCount: 0,
+    missCount: 0,
+    setCount: 0,
+    deleteCount: 0
+  };
+  isConnected = false;
+  keyPrefix;
+  /**
+   * Stores a cache entry in Redis.
+   *
+   * @param key - Cache key
+   * @param entry - Cache entry to store
+   * @returns Promise that resolves when entry is stored
+   */
+  async set(key, entry) {
+    await this.ensureConnected();
+    const redisKey = this.buildRedisKey(key);
+    const serializedEntry = JSON.stringify(entry);
+    const ttlMs = entry.expiresAt - Date.now();
+    const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1e3));
+    await this.client.set(redisKey, serializedEntry, "EX", ttlSeconds);
+    this.stats.setCount++;
+  }
+  /**
+   * Retrieves a cache entry from Redis.
+   *
+   * @param key - Cache key
+   * @returns Promise that resolves to cache entry or null if not found
+   */
+  async get(key) {
+    await this.ensureConnected();
+    const redisKey = this.buildRedisKey(key);
+    const serializedEntry = await this.client.get(redisKey);
+    if (!serializedEntry || typeof serializedEntry !== "string") {
+      this.stats.missCount++;
+      return null;
+    }
+    try {
+      const entry = JSON.parse(serializedEntry);
+      this.stats.hitCount++;
+      return entry;
+    } catch {
+      await this.client.del(redisKey);
+      this.stats.missCount++;
+      return null;
+    }
+  }
+  /**
+   * Removes a cache entry from Redis.
+   *
+   * @param key - Cache key to remove
+   * @returns Promise that resolves when entry is removed
+   */
+  async delete(key) {
+    await this.ensureConnected();
+    const redisKey = this.buildRedisKey(key);
+    await this.client.del(redisKey);
+    this.stats.deleteCount++;
+  }
+  /**
+   * Clears all cache entries from Redis.
+   * This removes all keys with the configured prefix.
+   *
+   * @returns Promise that resolves when cache is cleared
+   */
+  async clear() {
+    await this.ensureConnected();
+    const pattern = `${this.keyPrefix}*`;
+    const keys = await this.client.keys(pattern);
+    if (keys.length > 0) {
+      await this.client.del(...keys);
+    }
+    this.stats.hitCount = 0;
+    this.stats.missCount = 0;
+  }
+  /**
+   * Gets cache statistics.
+   *
+   * @returns Promise that resolves to cache statistics
+   */
+  async getStats() {
+    await this.ensureConnected();
+    const pattern = `${this.keyPrefix}*`;
+    const keys = await this.client.keys(pattern);
+    const entryCount = Array.isArray(keys) ? keys.length : 0;
+    const totalRequests = this.stats.hitCount + this.stats.missCount;
+    const hitRatio = totalRequests > 0 ? this.stats.hitCount / totalRequests : 0;
+    return {
+      hits: this.stats.hitCount,
+      misses: this.stats.missCount,
+      sets: this.stats.setCount,
+      deletes: this.stats.deleteCount,
+      size: entryCount,
+      hitRatio
+    };
+  }
+  /**
+   * Disposes of the Redis cache and cleans up resources.
+   *
+   * @returns Promise that resolves when cleanup is complete
+   */
+  async dispose() {
+    if (this.client && this.isConnected) {
+      await this.client.quit();
+      this.isConnected = false;
+    }
+  }
+  /**
+   * Ensures Redis connection is established.
+   *
+   * @private
+   * @returns Promise that resolves when connected
+   */
+  async ensureConnected() {
+    if (this.isConnected) return;
+    try {
+      this.client = await this.createIoRedisClient();
+      this.isConnected = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to connect to Redis: ${error instanceof Error ? error.message : "Unknown error"}. Ensure Redis is running and accessible, and install ioredis package.`
+      );
+    }
+  }
+  /**
+   * Creates an ioredis client.
+   *
+   * @private
+   * @returns Promise that resolves to ioredis client
+   */
+  async createIoRedisClient() {
+    const DEFAULT_TIMEOUT = 5e3;
+    const defaultOptions = {
+      connectTimeout: DEFAULT_TIMEOUT,
+      commandTimeout: DEFAULT_TIMEOUT,
+      enableOfflineQueue: false
+    };
+    const Redis = await import('ioredis');
+    const client = new Redis.default(this.config.url, {
+      connectTimeout: this.config.connectTimeout ?? defaultOptions.connectTimeout,
+      commandTimeout: this.config.commandTimeout ?? defaultOptions.commandTimeout,
+      enableOfflineQueue: defaultOptions.enableOfflineQueue
+    });
+    await new Promise((resolve, reject) => {
+      client.on("ready", resolve);
+      client.on("error", reject);
+    });
+    return client;
+  }
+  /**
+   * Builds a Redis key with the configured prefix.
+   *
+   * @private
+   * @param key - Base cache key
+   * @returns Redis key with prefix
+   */
+  buildRedisKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+};
+
+// src/cache/index.ts
+var CacheManager = class {
+  /**
+   * Creates a new cache manager with the specified configuration.
+   *
+   * @param config - Cache configuration
+   */
+  constructor(config) {
+    this.config = config;
+    this.strategy = this.createStrategy(config);
+  }
+  static {
+    __name(this, "CacheManager");
+  }
+  strategy;
+  /**
+   * Stores a value in the cache.
+   *
+   * @template T - Type of the value to cache
+   * @param key - Cache key
+   * @param value - Value to cache
+   * @param ttl - Optional TTL override in seconds
+   * @returns Promise that resolves when value is cached
+   */
+  async set(key, value, ttl) {
+    if (!this.config.isEnabled) return;
+    const finalTtl = ttl ?? this.config.ttl;
+    const entry = {
+      data: value,
+      expiresAt: Date.now() + finalTtl * 1e3,
+      createdAt: Date.now()
+    };
+    await this.strategy.set(key, entry);
+  }
+  /**
+   * Retrieves a value from the cache.
+   *
+   * @template T - Expected type of the cached value
+   * @param key - Cache key
+   * @returns Promise that resolves to cached value or null if not found/expired
+   */
+  async get(key) {
+    if (!this.config.isEnabled) return null;
+    const entry = await this.strategy.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      await this.strategy.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * Removes a value from the cache.
+   *
+   * @param key - Cache key to remove
+   * @returns Promise that resolves when value is removed
+   */
+  async delete(key) {
+    if (!this.config.isEnabled) return;
+    await this.strategy.delete(key);
+  }
+  /**
+   * Clears all cached values.
+   *
+   * @returns Promise that resolves when cache is cleared
+   */
+  async clear() {
+    if (!this.config.isEnabled) return;
+    await this.strategy.clear();
+  }
+  /**
+   * Checks if a key exists in the cache.
+   *
+   * @param key - Cache key to check
+   * @returns Promise that resolves to true if key exists and is not expired
+   */
+  async has(key) {
+    if (!this.config.isEnabled) return false;
+    const entry = await this.strategy.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      await this.strategy.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Gets cache statistics.
+   *
+   * @returns Promise that resolves to cache statistics
+   */
+  async getStats() {
+    return this.strategy.getStats();
+  }
+  /**
+   * Creates the appropriate cache strategy based on configuration.
+   *
+   * @private
+   * @param config - Cache configuration
+   * @returns Cache strategy instance
+   */
+  createStrategy(config) {
+    switch (config.strategy) {
+      case "redis":
+        if (!config.redisConfig) {
+          throw new Error("Redis configuration is required for Redis cache strategy");
+        }
+        return new RedisCacheStrategy(config.redisConfig);
+      case "memory":
+      default:
+        return new MemoryCacheStrategy(config.memoryConfig);
+    }
+  }
+  /**
+   * Disposes of the cache manager and cleans up resources.
+   *
+   * @returns Promise that resolves when cleanup is complete
+   */
+  async dispose() {
+    await this.strategy.dispose?.();
+  }
+};
+
+// src/domain/featureFlags/provider.ts
+var FeatureFlagProvider = class {
+  /**
+   * Creates a new feature flag provider.
+   *
+   * @param config - Provider configuration
+   * @param features - Record of feature flag keys to their default values
+   */
+  constructor(config, features) {
+    this.config = config;
+    this.features = features;
+    this.engine = new FeatureFlagEngine(features, config.isLoggingEnabled ?? false);
+    this.cacheManager = new CacheManager({
+      isEnabled: config.isCacheEnabled,
+      ttl: config.cacheTtl,
+      strategy: "memory"
+      // Default to memory, can be overridden
+    });
+    this.setupRefreshTimer();
+  }
+  static {
+    __name(this, "FeatureFlagProvider");
+  }
+  engine;
+  cacheManager;
+  subscribers = /* @__PURE__ */ new Set();
+  refreshTimer;
+  isInitialized = false;
+  features;
+  initializePromise;
+  /**
+   * Initializes the provider by loading initial data.
+   *
+   * @returns Promise that resolves when initialization is complete
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      return;
+    }
+    if (this.initializePromise) {
+      return this.initializePromise;
+    }
+    this.initializePromise = this.doInitialize();
+    return this.initializePromise;
+  }
+  /**
+   * Performs the actual initialization work.
+   *
+   * @private
+   * @returns Promise that resolves when initialization is complete
+   */
+  async doInitialize() {
+    try {
+      await this.refresh();
+      this.isInitialized = true;
+      this.log("Provider initialized successfully");
+    } catch (error) {
+      this.log("Failed to initialize provider:", error);
+      this.initializePromise = void 0;
+      throw error;
+    }
+  }
+  /**
+   * Gets a feature flag evaluation for the specified key and context.
+   *
+   * @param key - The feature flag key
+   * @param context - Optional context for evaluation
+   * @returns Promise resolving to the flag evaluation
+   */
+  async getFlag(key, context) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    if (this.config.isCacheEnabled) {
+      const cacheKey = this.generateCacheKey(key, context);
+      const cached = await this.cacheManager.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const evaluation = this.engine.evaluate(key, context);
+      await this.cacheManager.set(cacheKey, evaluation);
+      return evaluation;
+    }
+    return this.engine.evaluate(key, context);
+  }
+  /**
+   * Checks if a feature flag is enabled.
+   *
+   * @param key - The feature flag key
+   * @param context - Optional context for evaluation
+   * @returns Promise resolving to boolean indicating if flag is enabled
+   */
+  async isEnabled(key, context) {
+    const evaluation = await this.getFlag(key, context);
+    return evaluation.isEnabled;
+  }
+  /**
+   * Gets the value of a feature flag.
+   *
+   * @template T - The expected type of the flag value
+   * @param key - The feature flag key
+   * @param context - Optional context for evaluation
+   * @returns Promise resolving to the flag value
+   */
+  async getValue(key, context) {
+    const evaluation = await this.getFlag(key, context);
+    return evaluation.value;
+  }
+  /**
+   * Gets all feature flag evaluations for the given context.
+   *
+   * @param context - Optional context for evaluation
+   * @returns Promise resolving to record of flag evaluations
+   */
+  async getAllFlags(context) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    const results = {};
+    for (const key of Object.keys(this.features)) {
+      results[key] = await this.getFlag(key, context);
+    }
+    const engineFlags = this.engine.getFlags();
+    for (const flag of engineFlags) {
+      if (!(flag.key in results)) {
+        results[flag.key] = await this.getFlag(flag.key, context);
+      }
+    }
+    return results;
+  }
+  /**
+   * Refreshes the provider by fetching latest data from the source.
+   *
+   * @returns Promise that resolves when refresh is complete
+   */
+  async refresh() {
+    try {
+      const { flags, rules } = await this.fetchData();
+      this.engine.setFlags(flags);
+      this.engine.setRules(rules);
+      await this.cacheManager.clear();
+      this.notifySubscribers();
+      this.log(`Refreshed with ${flags.length} flags and ${rules.length} rules`);
+    } catch (error) {
+      this.log("Failed to refresh provider:", error);
+      throw error;
+    }
+  }
+  /**
+   * Subscribes to provider updates.
+   *
+   * @param callback - Function to call when provider updates
+   * @returns Unsubscribe function
+   */
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  /**
+   * Sets an override for a specific flag key.
+   *
+   * @param key - The flag key to override
+   * @param value - The value to force for this flag
+   */
+  setOverride(key, value) {
+    this.engine.setOverride(key, value);
+    void this.cacheManager.clear();
+    this.notifySubscribers();
+  }
+  /**
+   * Removes an override for a specific flag key.
+   *
+   * @param key - The flag key to remove override for
+   */
+  removeOverride(key) {
+    this.engine.removeOverride(key);
+    void this.cacheManager.clear();
+    this.notifySubscribers();
+  }
+  /**
+   * Clears all overrides.
+   */
+  clearOverrides() {
+    this.engine.clearOverrides();
+    void this.cacheManager.clear();
+    this.notifySubscribers();
+  }
+  /**
+   * Disposes of the provider, cleaning up resources.
+   */
+  dispose() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = void 0;
+    }
+    this.subscribers.clear();
+    void this.cacheManager.clear();
+    this.isInitialized = false;
+    this.log("Provider disposed");
+  }
+  /**
+   * Generates a cache key for flag evaluation.
+   *
+   * @protected
+   * @param key - Feature flag key
+   * @param context - Evaluation context
+   * @returns Cache key string
+   */
+  generateCacheKey(key, context) {
+    if (!context) {
+      return key;
+    }
+    const contextKey = JSON.stringify({
+      userId: context.userId,
+      userRole: context.userRole,
+      environment: context.environment,
+      platform: context.platform,
+      country: context.country,
+      version: context.version
+    });
+    return `${key}:${contextKey}`;
+  }
+  /**
+   * Sets up the automatic refresh timer if configured.
+   *
+   * @protected
+   */
+  setupRefreshTimer() {
+    if (this.config.refreshInterval > 0) {
+      this.refreshTimer = setInterval(() => {
+        void this.refresh().catch((error) => {
+          this.log("Auto-refresh failed:", error);
+        });
+      }, this.config.refreshInterval * 1e3);
+    }
+  }
+  /**
+   * Notifies all subscribers of provider updates.
+   *
+   * @protected
+   */
+  notifySubscribers() {
+    for (const callback of Array.from(this.subscribers)) {
+      try {
+        callback();
+      } catch (error) {
+        this.log("Subscriber callback error:", error);
+      }
+    }
+  }
+  /**
+   * Logs a message if logging is enabled.
+   *
+   * @protected
+   * @param args - Arguments to log
+   */
+  log(...args) {
+    if (this.config.isLoggingEnabled) {
+      console.log("[FeatureFlagProvider]", ...args);
+    }
+  }
+};
+
+// src/domain/featureFlags/providers/memory.ts
+var MemoryFeatureFlagProvider = class extends FeatureFlagProvider {
+  static {
+    __name(this, "MemoryFeatureFlagProvider");
+  }
+  flags = [];
+  rules = [];
+  /**
+   * Creates a new memory feature flag provider.
+   *
+   * @param config - Provider configuration
+   * @param features - Record of feature flag keys to their default values
+   */
+  constructor(config, features) {
+    super(config, features);
+    this.validateConfig();
+  }
+  /**
+   * Fetches flags and rules from memory (FEATURES constant).
+   *
+   * @protected
+   * @returns Promise resolving to flags and rules from memory
+   */
+  async fetchData() {
+    this.log("Fetching feature flags from memory (FEATURES constant)");
+    const currentTime = /* @__PURE__ */ new Date();
+    this.flags = Object.entries(this.features).map(
+      ([key, value]) => this.createFeatureFlagFromConstant(
+        key,
+        value,
+        currentTime
+      )
+    );
+    this.rules = [...this.getManualRules()];
+    this.log(`Loaded ${this.flags.length} flags and ${this.rules.length} rules from memory`);
+    return {
+      flags: this.flags,
+      rules: this.rules
+    };
+  }
+  /**
+   * Creates a FeatureFlag object from a FEATURES constant entry.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @param value - The value from FEATURES constant
+   * @param currentTime - Current timestamp
+   * @returns FeatureFlag object
+   */
+  createFeatureFlagFromConstant(key, value, currentTime) {
+    return {
+      key,
+      name: this.generateFlagName(key),
+      description: `Memory-based flag for ${key}`,
+      isEnabled: true,
+      value,
+      type: this.inferFlagType(value),
+      environment: "all",
+      rolloutPercentage: void 0,
+      createdAt: currentTime,
+      updatedAt: currentTime,
+      createdBy: "memory-system",
+      updatedBy: "memory-system"
+    };
+  }
+  /**
+   * Generates a human-readable name from a flag key.
+   *
+   * @private
+   * @param key - The feature flag key
+   * @returns Human-readable flag name
+   */
+  generateFlagName(key) {
+    return key.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+  }
+  /**
+   * Infers the flag type from its value.
+   *
+   * @private
+   * @param value - The flag value
+   * @returns The inferred type
+   */
+  inferFlagType(value) {
+    if (typeof value === "boolean") return "boolean";
+    if (typeof value === "string") return "string";
+    if (typeof value === "number") return "number";
+    return "json";
+  }
+  /**
+   * Gets manually added rules for memory provider.
+   *
+   * @private
+   * @returns Array of manually configured rules
+   */
+  getManualRules() {
+    return this.config.memoryRules ?? [];
+  }
+  /**
+   * Validates the memory provider configuration.
+   *
+   * @private
+   * @throws Error if configuration is invalid
+   */
+  validateConfig() {
+    if (this.config.provider !== "memory") {
+      throw new Error('Memory provider requires provider to be set to "memory"');
+    }
+    if (this.config.memoryRules && !Array.isArray(this.config.memoryRules)) {
+      throw new Error("memoryRules must be an array if provided");
+    }
+  }
+  /**
+   * Adds a rule to the memory provider at runtime.
+   *
+   * @param rule - The rule to add
+   */
+  addRule(rule) {
+    this.rules.push(rule);
+    this.engine.setRules(this.rules);
+    void this.cacheManager.clear();
+    this.notifySubscribers();
+    this.log(`Added rule: ${rule.name} for flag: ${rule.flagKey}`);
+  }
+  /**
+   * Removes a rule from the memory provider.
+   *
+   * @param ruleId - The ID of the rule to remove
+   */
+  removeRule(ruleId) {
+    const initialCount = this.rules.length;
+    this.rules = this.rules.filter((rule) => rule.id !== ruleId);
+    if (this.rules.length < initialCount) {
+      this.engine.setRules(this.rules);
+      void this.cacheManager.clear();
+      this.notifySubscribers();
+      this.log(`Removed rule with ID: ${ruleId}`);
+    } else {
+      this.log(`Rule with ID ${ruleId} not found`);
+    }
+  }
+  /**
+   * Updates a flag value in memory.
+   *
+   * @param key - The flag key to update
+   * @param value - The new value
+   * @param updateProps - Optional properties to update
+   */
+  updateFlag(key, value, updateProps) {
+    const flagIndex = this.flags.findIndex((flag) => flag.key === key);
+    if (flagIndex === -1) {
+      this.log(`Flag with key ${key} not found in memory`);
+      return;
+    }
+    const updatedFlag = {
+      ...this.flags[flagIndex],
+      value,
+      type: this.inferFlagType(value),
+      updatedAt: /* @__PURE__ */ new Date(),
+      updatedBy: "memory-runtime",
+      ...updateProps
+    };
+    this.flags[flagIndex] = updatedFlag;
+    this.engine.setFlags(this.flags);
+    void this.cacheManager.clear();
+    this.notifySubscribers();
+    this.log(`Updated flag: ${key} with new value:`, value);
+  }
+  /**
+   * Adds a new flag to memory at runtime.
+   *
+   * @param key - The flag key
+   * @param value - The flag value
+   * @param props - Optional flag properties
+   */
+  addFlag(key, value, props) {
+    if (this.flagExists(key)) {
+      return;
+    }
+    const newFlag = this.createNewFlag(key, value, props);
+    this.addFlagToStore(key, newFlag, value);
+  }
+  /**
+   * Checks if a flag with the given key exists.
+   */
+  flagExists(key) {
+    const exists = this.flags.some((flag) => flag.key === key);
+    if (exists) {
+      this.log(`Flag with key ${key} already exists in memory`);
+    }
+    return exists;
+  }
+  /**
+   * Creates a new flag object.
+   */
+  createNewFlag(key, value, props) {
+    const currentTime = /* @__PURE__ */ new Date();
+    const flagDefaults = this.getDefaultFlagProperties(key, value);
+    const flagProps = this.mergeWithUserProps(flagDefaults, props);
+    return {
+      key,
+      ...flagProps,
+      value,
+      type: flagDefaults.type,
+      createdAt: currentTime,
+      updatedAt: currentTime,
+      createdBy: "memory-runtime",
+      updatedBy: "memory-runtime"
+    };
+  }
+  /**
+   * Gets default properties for a new flag.
+   */
+  getDefaultFlagProperties(key, value) {
+    return {
+      name: this.generateFlagName(key),
+      description: `Runtime-added flag for ${key}`,
+      isEnabled: true,
+      type: this.inferFlagType(value),
+      environment: "all",
+      rolloutPercentage: void 0
+    };
+  }
+  /**
+   * Merges default properties with user-provided properties.
+   */
+  mergeWithUserProps(defaults, props) {
+    const merged = { ...defaults, ...props };
+    if (props?.type) {
+      merged.type = props.type;
+    }
+    return merged;
+  }
+  /**
+   * Adds the flag to the store and notifies systems.
+   */
+  addFlagToStore(key, newFlag, value) {
+    this.flags.push(newFlag);
+    this.engine.setFlags(this.flags);
+    void this.cacheManager.clear();
+    this.notifySubscribers();
+    this.log(`Added new flag: ${key} with value:`, value);
+  }
+  /**
+   * Removes a flag from memory.
+   *
+   * @param key - The flag key to remove
+   */
+  removeFlag(key) {
+    const initialCount = this.flags.length;
+    this.flags = this.flags.filter((flag) => flag.key !== key);
+    if (this.flags.length < initialCount) {
+      this.engine.setFlags(this.flags);
+      void this.cacheManager.clear();
+      this.notifySubscribers();
+      this.log(`Removed flag: ${key}`);
+    } else {
+      this.log(`Flag with key ${key} not found in memory`);
+    }
+  }
+  /**
+   * Gets all current flags in memory.
+   *
+   * @returns Array of current flags
+   */
+  getCurrentFlags() {
+    return [...this.flags];
+  }
+  /**
+   * Gets all current rules in memory.
+   *
+   * @returns Array of current rules
+   */
+  getCurrentRules() {
+    return [...this.rules];
+  }
+  /**
+   * Resets the memory provider to its initial state.
+   */
+  async reset() {
+    this.log("Resetting memory provider to initial state");
+    await this.refresh();
+  }
+  /**
+   * Gets statistics about the memory provider.
+   *
+   * @returns Provider statistics
+   */
+  getStats() {
+    return {
+      flagCount: this.flags.length,
+      ruleCount: this.rules.length,
+      cacheSize: 0,
+      // Memory cache size would need to be tracked
+      subscriberCount: this.subscribers.size,
+      isInitialized: this.isInitialized
+    };
+  }
+  /**
+   * Logs messages with MemoryFeatureFlagProvider prefix.
+   *
+   * @param args - Arguments to log
+   */
+  log(...args) {
+    if (this.config.isLoggingEnabled) {
+      console.log("[MemoryFeatureFlagProvider]", ...args);
+    }
+  }
+};
+
+// src/domain/featureFlags/providers/file.ts
+var FileFeatureFlagProvider = class extends FeatureFlagProvider {
+  static {
+    __name(this, "FileFeatureFlagProvider");
+  }
+  fileWatcher;
+  /**
+   * Creates a new file feature flag provider.
+   *
+   * @param config - Provider configuration with file settings
+   * @param features - Record of feature flag keys to their default values
+   */
+  constructor(config, features) {
+    super(config, features);
+    this.validateConfig();
+    this.setupFileWatcher();
+    throw new Error("File provider implementation coming soon");
+  }
+  /**
+   * Fetches flags and rules from the configuration file.
+   *
+   * @protected
+   * @returns Promise resolving to flags and rules from file
+   */
+  async fetchData() {
+    throw new Error(
+      'File Provider is not yet fully implemented. This requires dedicated file paths to be configured in @plyaz/core.\n\nRequired Implementation:\n1. Define standard file paths for feature flags\n2. Implement file reading and parsing logic\n3. Add YAML and JSON format support\n4. Set up file watching for hot reload\n5. Add file validation and error handling\n\nRecommended File Structure:\n@plyaz/core/config/\n├── feature-flags.json\n├── feature-flags.yaml\n├── rules/\n│   ├── targeting-rules.json\n│   └── rollout-rules.json\n└── environments/\n    ├── development.json\n    ├── staging.json\n    └── production.json\n\nExample Configuration:\n{\n  provider: "file",\n  fileConfig: {\n    filePath: "@plyaz/core/config/feature-flags.json",\n    format: "json",\n    shouldWatchForChanges: true\n  },\n  isCacheEnabled: true,\n  cacheTtl: 60\n}\n\nNote: Default provider should be memory for testing environments.\nFile provider is intended for configuration-driven deployments.\n\nMigration Note: This provider will be moved to @plyaz/core/src/domain/featureFlags/providers/'
+    );
+  }
+  /**
+   * Validates the file provider configuration.
+   *
+   * @private
+   * @throws Error if configuration is invalid
+   */
+  validateConfig() {
+    if (this.config.provider !== "file") {
+      throw new Error('File provider requires provider to be set to "file"');
+    }
+    if (!this.config.fileConfig) {
+      throw new Error("File configuration is required for file provider");
+    }
+    const { filePath, format } = this.config.fileConfig;
+    if (!filePath) {
+      throw new Error("File path is required");
+    }
+    if (!format || !["json", "yaml"].includes(format)) {
+      throw new Error('File format must be either "json" or "yaml"');
+    }
+  }
+  /**
+   * Sets up file watching for hot reload if enabled.
+   *
+   * @private
+   */
+  setupFileWatcher() {
+    if (!this.config.fileConfig?.shouldWatchForChanges) {
+      return;
+    }
+    this.log("File watching would be enabled for hot reload");
+    this.log("File path:", this.config.fileConfig.filePath);
+  }
+  /**
+   * Disposes of the file provider and stops file watching.
+   */
+  dispose() {
+    super.dispose();
+    if (this.fileWatcher) {
+      clearInterval(this.fileWatcher);
+      this.fileWatcher = void 0;
+      this.log("File watching stopped");
+    }
+  }
+  /**
+   * Gets information about the file provider.
+   *
+   * @returns File provider information
+   */
+  getFileInfo() {
+    return {
+      filePath: this.config.fileConfig?.filePath,
+      format: this.config.fileConfig?.format,
+      isWatchEnabled: Boolean(this.config.fileConfig?.shouldWatchForChanges),
+      isImplemented: false,
+      requiredImplementation: [
+        "File reading and parsing logic",
+        "YAML and JSON format support",
+        "File watching for hot reload",
+        "Standard file path configuration",
+        "File validation and error handling"
+      ]
+    };
+  }
+};
+
+// src/domain/featureFlags/providers/redis.ts
+var RedisFeatureFlagProvider = class extends FeatureFlagProvider {
+  static {
+    __name(this, "RedisFeatureFlagProvider");
+  }
+  /**
+   * Creates a new Redis feature flag provider.
+   *
+   * @param config - Provider configuration with Redis settings
+   * @param features - Record of feature flag keys to their default values
+   */
+  constructor(config, features) {
+    super(config, features);
+    this.validateConfig();
+    throw new Error("Redis provider requires @plyaz/core on Cache implementation");
+  }
+  /**
+   * Fetches flags and rules from Redis storage.
+   *
+   * @protected
+   * @returns Promise resolving to flags and rules from Redis
+   */
+  async fetchData() {
+    throw new Error(
+      'Redis Provider is not yet fully implemented. This requires integration with the cache layer.\n\nRequired Implementation:\n1. Integrate with cache/strategies/redis.ts\n2. Implement Redis data storage patterns\n3. Add Redis client management\n4. Set up data serialization/deserialization\n5. Add connection health monitoring\n6. Implement Redis key management strategies\n\nRedis Storage Patterns:\n- Hash-based storage (recommended)\n- List-based storage\n- String/JSON storage\n\nKey Structure:\n- {prefix}:flags - Feature flags hash\n- {prefix}:rules - Targeting rules list\n- {prefix}:overrides - Manual overrides hash\n- {prefix}:meta - Metadata and versioning\n\nExample Configuration:\n{\n  provider: "redis",\n  redisConfig: {\n    url: "redis://localhost:6379",\n    keyPrefix: "plyaz:feature_flags"\n  },\n  isCacheEnabled: true,\n  cacheTtl: 300\n}\n\nRedis Provider Benefits:\n- Distributed caching across instances\n- Real-time flag updates\n- Persistent storage option\n- High performance evaluation\n\nMigration Note: This provider will be moved to @plyaz/core/src/domain/featureFlags/providers/\nIt should integrate with the cache layer at @plyaz/core/src/cache/strategies/redis.ts'
+    );
+  }
+  /**
+   * Validates the Redis provider configuration.
+   *
+   * @private
+   * @throws Error if configuration is invalid
+   */
+  validateConfig() {
+    if (this.config.provider !== "redis") {
+      throw new Error('Redis provider requires provider to be set to "redis"');
+    }
+    if (!this.config.redisConfig) {
+      throw new Error("Redis configuration is required for Redis provider");
+    }
+    if (!this.config.redisConfig.url) {
+      throw new Error("Redis URL is required");
+    }
+    if (!this.isValidRedisUrl(this.config.redisConfig.url)) {
+      throw new Error("Redis URL must be a valid Redis connection string (redis:// or rediss://)");
+    }
+    this.log("Redis provider configuration is valid, but implementation is not ready");
+    this.log("Redis URL:", this.config.redisConfig.url);
+    this.log("Key Prefix:", this.config.redisConfig.keyPrefix ?? "feature_flags");
+  }
+  /**
+   * Validates Redis URL format.
+   *
+   * @private
+   * @param url - URL to validate
+   * @returns True if valid Redis URL
+   */
+  isValidRedisUrl(url) {
+    return url.startsWith("redis://") || url.startsWith("rediss://");
+  }
+  /**
+   * Gets Redis provider information.
+   *
+   * @returns Redis provider status information
+   */
+  getRedisInfo() {
+    return {
+      url: this.config.redisConfig?.url,
+      keyPrefix: this.config.redisConfig?.keyPrefix ?? "feature_flags",
+      isImplemented: false,
+      requiredImplementation: [
+        "Integration with cache/strategies/redis.ts",
+        "Redis data storage patterns",
+        "Client management and health monitoring",
+        "Data serialization/deserialization",
+        "Key management strategies"
+      ],
+      recommendedPatterns: [
+        "Hash-based storage for flags",
+        "List-based storage for rules",
+        "Pub/Sub for real-time updates",
+        "TTL for automatic cleanup"
+      ]
+    };
+  }
+};
+
+// src/domain/featureFlags/providers/api.ts
+var ApiFeatureFlagProvider = class extends FeatureFlagProvider {
+  static {
+    __name(this, "ApiFeatureFlagProvider");
+  }
+  /**
+   * Creates a new API feature flag provider.
+   *
+   * @param config - Provider configuration with API settings
+   * @throws Error indicating that @plyaz/api implementation is required
+   */
+  constructor(config, features) {
+    super(config, features);
+    this.validateConfig();
+    throw new Error("API provider requires @plyaz/api package implementation");
+  }
+  /**
+   * Fetches flags and rules from the API endpoint.
+   * Currently throws an error as the API implementation is not ready.
+   *
+   * @protected
+   * @returns Promise that rejects with implementation error
+   * @throws Error indicating missing API implementation
+   */
+  async fetchData() {
+    throw new Error(
+      'API Provider is not yet implemented. This requires @plyaz/api package with the following endpoints:\n\nRequired API Endpoints (to be implemented in @plyaz/api):\n- GET /api/v1/feature-flags (get all flags)\n- GET /api/v1/feature-flag-rules (get all rules)\n- POST /api/v1/feature-flags/evaluate (evaluate flags)\n- POST /api/v1/feature-flags/evaluate/bulk (bulk evaluation)\n\nRequired Backend Implementation:\n1. Install and configure @plyaz/api package\n2. Implement the API endpoints in NestJS modules\n3. Set up authentication (API key or JWT)\n4. Configure CORS and rate limiting\n5. Add request/response validation\n6. Set up database integration with @plyaz/db\n\nExample Configuration:\n{\n  provider: "api",\n  apiEndpoint: "https://api.plyaz.co.uk",\n  apiKey: "your-api-key",\n  isCacheEnabled: true,\n  cacheTtl: 300\n}\n\nSee /docs/feature-flag-to-implement/api-requirements.md for complete implementation details.\n\nMigration Note: This provider will be moved to @plyaz/core/src/domain/featureFlags/providers/'
+    );
+  }
+  /**
+   * Validates the API provider configuration.
+   *
+   * @private
+   * @throws Error if configuration is invalid or incomplete
+   */
+  validateConfig() {
+    if (this.config.provider !== "api") {
+      throw new Error('API provider requires provider to be set to "api"');
+    }
+    if (!this.config.apiEndpoint) {
+      throw new Error(
+        'API endpoint is required for API provider. Set apiEndpoint in your configuration.\nExample: apiEndpoint: "https://api.plyaz.co.uk"'
+      );
+    }
+    if (!this.config.apiKey) {
+      throw new Error(
+        "API key is required for API provider. Set apiKey in your configuration.\nExample: apiKey: process.env.FEATURE_FLAG_API_KEY"
+      );
+    }
+    if (!this.isValidUrl(this.config.apiEndpoint)) {
+      throw new Error(
+        `API endpoint must be a valid URL. Received: ${this.config.apiEndpoint}
+Example: "https://api.plyaz.co.uk"`
+      );
+    }
+    this.log("API provider configuration is valid, but implementation is not ready");
+    this.log("API Endpoint:", this.config.apiEndpoint);
+    this.log("API Key:", this.config.apiKey ? "[SET]" : "[MISSING]");
+  }
+  /**
+   * Validates URL format.
+   *
+   * @private
+   * @param url - URL to validate
+   * @returns True if valid URL
+   */
+  isValidUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Gets API provider status and configuration info.
+   *
+   * @returns API provider status information
+   */
+  getApiInfo() {
+    return {
+      endpoint: this.config.apiEndpoint,
+      hasApiKey: Boolean(this.config.apiKey),
+      isImplemented: false,
+      requiredPackages: ["@plyaz/api"],
+      documentationPath: "/docs/feature-flag-to-implement/api-requirements.md"
+    };
+  }
+};
+
+// src/domain/featureFlags/providers/database.ts
+var DatabaseFeatureFlagProvider = class extends FeatureFlagProvider {
+  static {
+    __name(this, "DatabaseFeatureFlagProvider");
+  }
+  /**
+   * Creates a new database feature flag provider.
+   *
+   * @param config - Provider configuration with database settings
+   * @throws Error indicating that @plyaz/db implementation is required
+   */
+  constructor(config, features) {
+    super(config, features);
+    this.validateConfig();
+    throw new Error("Database provider requires @plyaz/db package implementation");
+  }
+  /**
+   * Fetches flags and rules from the database.
+   * Currently throws an error as the database implementation is not ready.
+   *
+   * @protected
+   * @returns Promise that rejects with implementation error
+   * @throws Error indicating missing database implementation
+   */
+  async fetchData() {
+    throw new Error(
+      'Database Provider is not yet implemented. This requires @plyaz/db package with the following components:\n\nRequired Database Setup:\n1. PostgreSQL or MySQL database\n2. Tables created using provided schema\n3. ORM implementation (Drizzle or Prisma)\n4. Repository pattern for data access\n5. NestJS modules and services\n\nRequired Tables:\n- feature_flags (main flags table)\n- feature_flag_rules (targeting rules table)\n- feature_flag_evaluations (audit log table)\n- feature_flag_overrides (temporary overrides table)\n\nDatabase Schema:\nThe complete schema is provided in:\n/docs/feature-flag-to-implement/database-requirements.md\n\nRequired Implementation Steps:\n1. Install and configure @plyaz/db package\n2. Set up database connection and ORM\n3. Create tables using the provided SQL schema\n4. Implement FeatureFlagsRepository interface\n5. Add NestJS modules, services, and controllers\n6. Set up database migrations\n7. Add comprehensive test coverage\n\nExample Configuration:\n{\n  provider: "database",\n  databaseConfig: {\n    connectionString: "postgresql://user:pass@localhost:5432/plyaz",\n    tableName: "feature_flags"\n  },\n  isCacheEnabled: true,\n  cacheTtl: 300\n}\n\nSee /docs/feature-flag-to-implement/database-requirements.md for complete implementation details.\n\nMigration Note: This provider will be moved to @plyaz/core/src/domain/featureFlags/providers/'
+    );
+  }
+  /**
+   * Validates the database provider configuration.
+   *
+   * @private
+   * @throws Error if configuration is invalid or incomplete
+   */
+  validateConfig() {
+    this.validateProviderType();
+    this.validateDatabaseConfig();
+    this.validateConnectionString();
+    this.logConfigurationStatus();
+  }
+  validateProviderType() {
+    if (this.config.provider !== "database") {
+      throw new Error('Database provider requires provider to be set to "database"');
+    }
+  }
+  validateDatabaseConfig() {
+    if (!this.config.databaseConfig) {
+      throw new Error(
+        'Database configuration is required for database provider. Set databaseConfig in your configuration.\nExample: databaseConfig: { connectionString: "postgresql://...", tableName: "feature_flags" }'
+      );
+    }
+  }
+  validateConnectionString() {
+    const { connectionString, tableName } = this.config.databaseConfig;
+    if (!connectionString) {
+      throw new Error(
+        'Database connection string is required. Set connectionString in your databaseConfig.\nExample: connectionString: "postgresql://user:pass@localhost:5432/plyaz"'
+      );
+    }
+    if (!this.isValidPostgresUrl(connectionString) && !this.isValidMysqlUrl(connectionString)) {
+      throw new Error(
+        `Database connection string must be a valid PostgreSQL or MySQL URL. Received: ${connectionString}
+Examples:
+- PostgreSQL: "postgresql://user:pass@localhost:5432/plyaz"
+- MySQL: "mysql://user:pass@localhost:3306/plyaz"`
+      );
+    }
+    if (!tableName || typeof tableName !== "string") {
+      throw new Error("Database provider requires databaseConfig.tableName");
+    }
+  }
+  logConfigurationStatus() {
+    const { connectionString, tableName } = this.config.databaseConfig;
+    this.log("Database provider configuration is valid, but implementation is not ready");
+    this.log("Connection String:", this.maskConnectionString(connectionString));
+    this.log("Table Name:", tableName ?? "feature_flags (default)");
+  }
+  /**
+   * Validates PostgreSQL URL format.
+   *
+   * @private
+   * @param url - URL to validate
+   * @returns True if valid PostgreSQL URL
+   */
+  isValidPostgresUrl(url) {
+    return url.startsWith("postgresql://") || url.startsWith("postgres://");
+  }
+  /**
+   * Validates MySQL URL format.
+   *
+   * @private
+   * @param url - URL to validate
+   * @returns True if valid MySQL URL
+   */
+  isValidMysqlUrl(url) {
+    return url.startsWith("mysql://");
+  }
+  /**
+   * Masks sensitive parts of connection string for logging.
+   *
+   * @private
+   * @param connectionString - Original connection string
+   * @returns Masked connection string
+   */
+  maskConnectionString(connectionString) {
+    try {
+      const url = new URL(connectionString);
+      const masked = `${url.protocol}//${url.username}:****@${url.host}${url.pathname}`;
+      return masked;
+    } catch {
+      return "[INVALID_URL]";
+    }
+  }
+  /**
+   * Gets database provider status and configuration info.
+   *
+   * @returns Database provider status information
+   */
+  getDatabaseInfo() {
+    return {
+      connectionString: this.config.databaseConfig?.connectionString ? this.maskConnectionString(this.config.databaseConfig.connectionString) : void 0,
+      tableName: this.config.databaseConfig?.tableName ?? "feature_flags",
+      isImplemented: false,
+      requiredPackages: ["@plyaz/db"],
+      recommendedORM: ["drizzle-orm", "prisma"],
+      documentationPath: "/docs/feature-flag-to-implement/database-requirements.md",
+      schemaPath: "/docs/feature-flag-to-implement/database-requirements.md#database-schema"
+    };
+  }
+};
+
+// src/domain/featureFlags/providers/factory.ts
+var PROVIDER_REGISTRY = {
+  memory: MemoryFeatureFlagProvider,
+  file: FileFeatureFlagProvider,
+  redis: RedisFeatureFlagProvider,
+  api: ApiFeatureFlagProvider,
+  database: DatabaseFeatureFlagProvider
+};
+var FeatureFlagProviderFactory = class {
+  static {
+    __name(this, "FeatureFlagProviderFactory");
+  }
+  /**
+   * Creates a new feature flag provider instance based on configuration.
+   *
+   * @param config - Provider configuration
+   * @param features - Record of feature flag keys to their default values
+   * @returns Configured provider instance
+   * @throws Error if provider type is unsupported or configuration is invalid
+   */
+  static create(config, features) {
+    this.validateConfig(config);
+    const ProviderClass = PROVIDER_REGISTRY[config.provider];
+    if (!ProviderClass) {
+      throw new Error(
+        `Unsupported provider type: ${config.provider}. Supported types: ${this.getSupportedProviders().join(", ")}`
+      );
+    }
+    try {
+      return new ProviderClass(config, features);
+    } catch (error) {
+      throw new Error(
+        `Failed to create ${config.provider} provider: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Creates a provider with automatic initialization.
+   *
+   * @param config - Provider configuration
+   * @param features - Record of feature flag keys to their default values
+   * @returns Promise resolving to initialized provider instance
+   */
+  static async createAndInitialize(config, features) {
+    const provider = this.create(config, features);
+    await provider.initialize();
+    return provider;
+  }
+  /**
+   * Gets a list of all supported provider types.
+   *
+   * @returns Array of supported provider names
+   */
+  static getSupportedProviders() {
+    return Object.keys(PROVIDER_REGISTRY);
+  }
+  /**
+   * Checks if a provider type is supported.
+   *
+   * @param providerType - Provider type to check
+   * @returns True if provider type is supported
+   */
+  static isProviderSupported(providerType) {
+    return providerType in PROVIDER_REGISTRY;
+  }
+  /**
+   * Gets provider information including implementation status.
+   *
+   * @returns Record of provider information
+   */
+  static getProvidersInfo() {
+    return {
+      memory: {
+        name: "Memory Provider",
+        isImplemented: true,
+        description: "In-memory provider using FEATURES constant"
+      },
+      file: {
+        name: "File Provider",
+        isImplemented: true,
+        description: "File-based provider supporting JSON and YAML formats"
+      },
+      redis: {
+        name: "Redis Provider",
+        isImplemented: true,
+        description: "Redis-based provider for distributed caching",
+        requirements: ["ioredis or redis package"]
+      },
+      api: {
+        name: "API Provider",
+        isImplemented: false,
+        description: "Remote API provider for centralized flag management",
+        requirements: ["@plyaz/api package", "API endpoints implementation"]
+      },
+      database: {
+        name: "Database Provider",
+        isImplemented: false,
+        description: "Database provider for persistent flag storage",
+        requirements: ["@plyaz/db package", "Database schema setup"]
+      }
+    };
+  }
+  /**
+   * Creates a default memory provider for testing environments.
+   *
+   * @param features - Record of feature flag keys to their default values
+   * @param overrides - Optional configuration overrides
+   * @returns Memory provider instance
+   */
+  static createDefault(features, overrides) {
+    const defaultConfig = {
+      provider: "memory",
+      isCacheEnabled: true,
+      cacheTtl: 300,
+      // 5 minutes
+      refreshInterval: 0,
+      // No auto-refresh
+      isLoggingEnabled: false,
+      shouldFallbackToDefaults: true,
+      ...overrides
+    };
+    return this.create(defaultConfig, features);
+  }
+  /**
+   * Validates provider configuration before instantiation.
+   *
+   * @private
+   * @param config - Configuration to validate
+   * @throws Error if configuration is invalid
+   */
+  static validateConfig(config) {
+    if (!config) {
+      throw new Error("Provider configuration is required");
+    }
+    if (!config.provider) {
+      throw new Error("Provider type is required in configuration");
+    }
+    if (!this.isProviderSupported(config.provider)) {
+      throw new Error(
+        `Unsupported provider type: ${config.provider}. Supported providers: ${this.getSupportedProviders().join(", ")}`
+      );
+    }
+    if (config.isCacheEnabled && config.cacheTtl <= 0) {
+      throw new Error("Cache TTL must be greater than 0 when caching is enabled");
+    }
+    if (config.refreshInterval < 0) {
+      throw new Error("Refresh interval cannot be negative");
+    }
+    this.validateProviderSpecificConfig(config);
+  }
+  /**
+   * Validates provider-specific configuration requirements.
+   *
+   * @private
+   * @param config - Configuration to validate
+   * @throws Error if provider-specific configuration is invalid
+   */
+  static validateProviderSpecificConfig(config) {
+    const validationMap = {
+      file: /* @__PURE__ */ __name(() => this.validateFileConfig(config), "file"),
+      redis: /* @__PURE__ */ __name(() => this.validateRedisConfig(config), "redis"),
+      api: /* @__PURE__ */ __name(() => this.validateApiConfig(config), "api"),
+      database: /* @__PURE__ */ __name(() => this.validateDatabaseConfig(config), "database"),
+      memory: /* @__PURE__ */ __name(() => {
+      }, "memory")
+      // Memory provider has no additional requirements
+    };
+    const validator = validationMap[config.provider];
+    if (!validator) {
+      throw new Error(`Unknown provider type: ${config.provider}`);
+    }
+    validator();
+  }
+  static validateFileConfig(config) {
+    if (!config.fileConfig) {
+      throw new Error("File configuration is required for file provider");
+    }
+  }
+  static validateRedisConfig(config) {
+    if (!config.redisConfig) {
+      throw new Error("Redis configuration is required for Redis provider");
+    }
+  }
+  static validateApiConfig(config) {
+    if (!config.apiEndpoint) {
+      throw new Error("API endpoint is required for API provider");
+    }
+  }
+  static validateDatabaseConfig(config) {
+    if (!config.databaseConfig) {
+      throw new Error("Database configuration is required for database provider");
+    }
+  }
+};
+var DEFAULT_FEATURE_FLAG_CONFIG = {
+  provider: "memory",
+  isCacheEnabled: true,
+  cacheTtl: 300,
+  // 5 minutes
+  refreshInterval: 0,
+  // No auto-refresh
+  shouldFallbackToDefaults: true,
+  isLoggingEnabled: false
+};
+var FeatureFlagSystem = {
+  /**
+   * Initialize for frontend/client applications.
+   */
+  initializeForFrontend: /* @__PURE__ */ __name(async (config = {}) => {
+    const finalConfig = {
+      ...DEFAULT_FEATURE_FLAG_CONFIG,
+      ...config
+    };
+    const provider = FeatureFlagProviderFactory.create(finalConfig, FEATURES);
+    await provider.initialize();
+    return provider;
+  }, "initializeForFrontend"),
+  /**
+   * Initialize for backend/server applications.
+   */
+  initializeForBackend: /* @__PURE__ */ __name(async (config = {}) => {
+    const finalConfig = {
+      ...DEFAULT_FEATURE_FLAG_CONFIG,
+      ...config
+    };
+    const provider = FeatureFlagProviderFactory.create(finalConfig, FEATURES);
+    await provider.initialize();
+    return provider;
+  }, "initializeForBackend"),
+  /**
+   * Initialize for testing environments.
+   */
+  initializeForTesting: /* @__PURE__ */ __name(async (overrides = {}) => {
+    const provider = FeatureFlagProviderFactory.createDefault(FEATURES, {
+      provider: "memory",
+      isCacheEnabled: false,
+      isLoggingEnabled: false
+    });
+    await provider.initialize();
+    Object.entries(overrides).forEach(([key, value]) => {
+      provider.setOverride(key, value);
+    });
+    return provider;
+  }, "initializeForTesting")
+};
+var FeatureFlagController = class {
+  constructor(featureFlagService) {
+    this.featureFlagService = featureFlagService;
+  }
+  async evaluateFlag(key, body = {}) {
+    try {
+      return await this.featureFlagService.evaluateFlag(key, body.context);
+    } catch (error) {
+      throw new HttpException(
+        `Failed to evaluate flag: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async isEnabled(key, body = {}) {
+    try {
+      const isEnabled = await this.featureFlagService.isEnabled(key, body.context);
+      return { isEnabled };
+    } catch (error) {
+      throw new HttpException(
+        `Failed to check flag status: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async evaluateAllFlags(body = {}) {
+    try {
+      return await this.featureFlagService.getAllFlags(body.context);
+    } catch (error) {
+      throw new HttpException(
+        `Failed to evaluate all flags: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.INTERNAL_SERVER_ERROR
+      );
+    }
+  }
+  async createFlag(createData) {
+    try {
+      return await this.featureFlagService.createFlag(createData);
+    } catch (error) {
+      throw new HttpException(
+        `Failed to create flag: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async updateFlag(key, updateData) {
+    try {
+      return await this.featureFlagService.updateFlag(key, updateData);
+    } catch (error) {
+      throw new HttpException(
+        `Failed to update flag: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async deleteFlag(key) {
+    try {
+      await this.featureFlagService.deleteFlag(key);
+      return { isSuccessful: true };
+    } catch (error) {
+      throw new HttpException(
+        `Failed to delete flag: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async setOverride(key, value) {
+    try {
+      await this.featureFlagService.setOverride(key, value);
+      return { isSuccessful: true };
+    } catch (error) {
+      throw new HttpException(
+        `Failed to set override: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async removeOverride(key) {
+    try {
+      await this.featureFlagService.removeOverride(key);
+      return { isSuccessful: true };
+    } catch (error) {
+      throw new HttpException(
+        `Failed to remove override: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async getAllFeatureFlags(environment) {
+    try {
+      return await this.featureFlagService.getAllFeatureFlags(environment);
+    } catch (error) {
+      throw new HttpException(
+        `Failed to get flags: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.INTERNAL_SERVER_ERROR
+      );
+    }
+  }
+  async getFlagRules(key) {
+    try {
+      return await this.featureFlagService.getFlagRules(key);
+    } catch (error) {
+      throw new HttpException(
+        `Failed to get flag rules: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.BAD_REQUEST
+      );
+    }
+  }
+  async refreshCache() {
+    try {
+      await this.featureFlagService.refreshCache();
+      return { isSuccessful: true };
+    } catch (error) {
+      throw new HttpException(
+        `Failed to refresh cache: ${error instanceof Error ? error.message : "Unknown error"}`,
+        HttpStatus.INTERNAL_SERVER_ERROR
+      );
+    }
+  }
+};
+__name(FeatureFlagController, "FeatureFlagController");
+__decorateClass([
+  Post(":key/evaluate"),
+  __decorateParam(0, Param("key")),
+  __decorateParam(1, Body())
+], FeatureFlagController.prototype, "evaluateFlag", 1);
+__decorateClass([
+  Post(":key/enabled"),
+  __decorateParam(0, Param("key")),
+  __decorateParam(1, Body())
+], FeatureFlagController.prototype, "isEnabled", 1);
+__decorateClass([
+  Post("evaluate-all"),
+  __decorateParam(0, Body())
+], FeatureFlagController.prototype, "evaluateAllFlags", 1);
+__decorateClass([
+  Post(),
+  __decorateParam(0, Body())
+], FeatureFlagController.prototype, "createFlag", 1);
+__decorateClass([
+  Put(":key"),
+  __decorateParam(0, Param("key")),
+  __decorateParam(1, Body())
+], FeatureFlagController.prototype, "updateFlag", 1);
+__decorateClass([
+  Delete(":key"),
+  __decorateParam(0, Param("key"))
+], FeatureFlagController.prototype, "deleteFlag", 1);
+__decorateClass([
+  Post(":key/override"),
+  __decorateParam(0, Param("key")),
+  __decorateParam(1, Body("value"))
+], FeatureFlagController.prototype, "setOverride", 1);
+__decorateClass([
+  Delete(":key/override"),
+  __decorateParam(0, Param("key"))
+], FeatureFlagController.prototype, "removeOverride", 1);
+__decorateClass([
+  Get(),
+  __decorateParam(0, Query("environment"))
+], FeatureFlagController.prototype, "getAllFeatureFlags", 1);
+__decorateClass([
+  Get(":key/rules"),
+  __decorateParam(0, Param("key"))
+], FeatureFlagController.prototype, "getFlagRules", 1);
+__decorateClass([
+  Post("refresh")
+], FeatureFlagController.prototype, "refreshCache", 1);
+FeatureFlagController = __decorateClass([
+  Controller("feature-flags")
+], FeatureFlagController);
+var FeatureFlagService = class {
+  constructor(featureFlagRepository) {
+    this.featureFlagRepository = featureFlagRepository;
+  }
+  logger = new Logger(FeatureFlagService.name);
+  provider;
+  /**
+   * Initializes the service on module startup.
+   */
+  async onModuleInit() {
+    try {
+      await this.initializeProvider();
+      this.logger.log("Feature flag service initialized successfully");
+    } catch (error) {
+      this.logger.error("Failed to initialize feature flag service", error);
+      throw error;
+    }
+  }
+  /**
+   * Cleans up resources on module shutdown.
+   */
+  async onModuleDestroy() {
+    this.provider.dispose();
+    this.logger.log("Feature flag service disposed");
+  }
+  /**
+   * Initializes the feature flag provider.
+   */
+  async initializeProvider() {
+    const DEFAULT_CACHE_TTL = 300;
+    const config = {
+      provider: process.env.FEATURE_FLAG_PROVIDER ?? "database",
+      isCacheEnabled: process.env.FEATURE_FLAG_CACHE_ENABLED === "true",
+      cacheTtl: Number(process.env.FEATURE_FLAG_CACHE_TTL) || DEFAULT_CACHE_TTL,
+      refreshInterval: Number(process.env.FEATURE_FLAG_REFRESH_INTERVAL) || 0,
+      shouldFallbackToDefaults: true,
+      isLoggingEnabled: process.env.NODE_ENV === "development"
+    };
+    this.provider = FeatureFlagProviderFactory.create(config, FEATURES);
+    await this.provider.initialize();
+  }
+  /**
+   * Gets the current provider instance.
+   */
+  getProvider() {
+    if (!this.provider) {
+      throw new Error("Feature flag provider not initialized");
+    }
+    return this.provider;
+  }
+  /**
+   * Evaluates a feature flag for the given context.
+   *
+   * @param key - Feature flag key
+   * @param context - Evaluation context
+   * @returns Feature flag evaluation result
+   */
+  async evaluateFlag(key, context) {
+    try {
+      const provider = this.getProvider();
+      const evaluation = await provider.getFlag(key, context);
+      this.logger.debug(`Evaluated flag ${key}: ${evaluation.isEnabled}`, {
+        key,
+        value: evaluation.value,
+        reason: evaluation.reason,
+        context
+      });
+      return evaluation;
+    } catch (error) {
+      this.logger.error(`Failed to evaluate flag ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Checks if a feature flag is enabled.
+   *
+   * @param key - Feature flag key
+   * @param context - Evaluation context
+   * @returns Boolean indicating if flag is enabled
+   */
+  async isEnabled(key, context) {
+    const evaluation = await this.evaluateFlag(key, context);
+    return evaluation.isEnabled;
+  }
+  /**
+   * Gets all feature flags with their evaluations.
+   *
+   * @param context - Evaluation context
+   * @returns All feature flag evaluations
+   */
+  async getAllFlags(context) {
+    try {
+      const provider = this.getProvider();
+      const flags = await provider.getAllFlags();
+      this.logger.debug(`Evaluated all flags for context`, {
+        flagCount: Object.keys(flags).length,
+        context
+      });
+      return flags;
+    } catch (error) {
+      this.logger.error("Failed to evaluate all flags", error);
+      throw error;
+    }
+  }
+  /**
+   * Creates a new feature flag.
+   *
+   * @param createData - Flag creation data
+   * @returns Created feature flag
+   */
+  async createFlag(createData) {
+    try {
+      const flag = await this.featureFlagRepository.createFlag(createData);
+      await this.refreshCache();
+      this.logger.log(`Created feature flag: ${createData.key}`);
+      return flag;
+    } catch (error) {
+      this.logger.error(`Failed to create flag ${createData.key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Updates an existing feature flag.
+   *
+   * @param key - Feature flag key
+   * @param updateData - Flag update data
+   * @returns Updated feature flag
+   */
+  async updateFlag(key, updateData) {
+    try {
+      const flag = await this.featureFlagRepository.updateFlag(key, updateData);
+      await this.refreshCache();
+      this.logger.log(`Updated feature flag: ${key}`);
+      return flag;
+    } catch (error) {
+      this.logger.error(`Failed to update flag ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Deletes a feature flag.
+   *
+   * @param key - Feature flag key
+   */
+  async deleteFlag(key) {
+    try {
+      await this.featureFlagRepository.deleteFlag(key);
+      await this.refreshCache();
+      this.logger.log(`Deleted feature flag: ${key}`);
+    } catch (error) {
+      this.logger.error(`Failed to delete flag ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Sets a manual override for a flag.
+   *
+   * @param key - Feature flag key
+   * @param value - Override value
+   */
+  async setOverride(key, value) {
+    try {
+      const provider = this.getProvider();
+      provider.setOverride(key, value);
+      this.logger.log(`Set override for flag ${key}: ${value}`);
+    } catch (error) {
+      this.logger.error(`Failed to set override for flag ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Removes a manual override for a flag.
+   *
+   * @param key - Feature flag key
+   */
+  async removeOverride(key) {
+    try {
+      const provider = this.getProvider();
+      provider.removeOverride(key);
+      this.logger.log(`Removed override for flag ${key}`);
+    } catch (error) {
+      this.logger.error(`Failed to remove override for flag ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Gets all available feature flags.
+   *
+   * @param environment - Filter by environment
+   * @returns List of feature flags
+   */
+  async getAllFeatureFlags(environment) {
+    try {
+      return await this.featureFlagRepository.getAllFlags(environment);
+    } catch (error) {
+      this.logger.error("Failed to get all feature flags", error);
+      throw error;
+    }
+  }
+  /**
+   * Gets all rules for a specific flag.
+   *
+   * @param key - Feature flag key
+   * @returns List of rules for the flag
+   */
+  async getFlagRules(key) {
+    try {
+      return await this.featureFlagRepository.getFlagRules(key);
+    } catch (error) {
+      this.logger.error(`Failed to get rules for flag ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Forces a refresh of the feature flag cache.
+   */
+  async refreshCache() {
+    try {
+      const provider = this.getProvider();
+      await provider.refresh();
+      this.logger.log("Feature flag cache refreshed");
+    } catch (error) {
+      this.logger.error("Failed to refresh feature flag cache", error);
+      throw error;
+    }
+  }
+  /**
+   * Gets provider health status.
+   *
+   * @returns Provider health information
+   */
+  async getHealthStatus() {
+    return {
+      isInitialized: !!this.provider,
+      provider: "database",
+      // or get from config
+      isCacheEnabled: true
+      // or get from config
+    };
+  }
+};
+__name(FeatureFlagService, "FeatureFlagService");
+FeatureFlagService = __decorateClass([
+  Injectable()
+], FeatureFlagService);
+var FeatureFlagRepository = class {
+  logger = new Logger(FeatureFlagRepository.name);
+  // 24 * 60 * 60 * 1000
+  // TODO: Inject database service when @plyaz/db is available
+  // constructor(private readonly databaseService: DatabaseService) {}
+  /**
+   * Creates a new feature flag in the database.
+   *
+   * @param createData - Flag creation data
+   * @returns Created feature flag
+   */
+  async createFlag(createData) {
+    this.logger.log(`Creating flag: ${createData.key}`);
+    const currentTime = /* @__PURE__ */ new Date();
+    const newFlag = {
+      key: createData.key,
+      name: createData.name,
+      description: createData.description ?? `Feature flag for ${createData.key}`,
+      isEnabled: createData.isEnabled ?? true,
+      value: createData.value,
+      type: this.inferFlagType(createData.value),
+      environment: createData.environment ?? "all",
+      rolloutPercentage: createData.rolloutPercentage,
+      createdAt: currentTime,
+      updatedAt: currentTime,
+      createdBy: "api",
+      updatedBy: "api"
+    };
+    this.logger.debug(`Flag created: ${createData.key}`, newFlag);
+    return newFlag;
+  }
+  /**
+   * Updates an existing feature flag.
+   *
+   * @param key - Feature flag key
+   * @param updateData - Flag update data
+   * @returns Updated feature flag
+   */
+  async updateFlag(key, updateData) {
+    this.logger.log(`Updating flag: ${key}`);
+    const updatedFlag = {
+      key,
+      name: updateData.name ?? `Updated ${key}`,
+      description: updateData.description ?? `Updated feature flag for ${key}`,
+      isEnabled: updateData.isEnabled ?? true,
+      value: updateData.value ?? true,
+      type: updateData.value ? this.inferFlagType(updateData.value) : "boolean",
+      environment: updateData.environment ?? "all",
+      rolloutPercentage: updateData.rolloutPercentage,
+      createdAt: new Date(Date.now() - FeatureFlagRepository.ONE_DAY_MS),
+      // 1 day ago
+      updatedAt: /* @__PURE__ */ new Date(),
+      createdBy: "api",
+      updatedBy: "api"
+    };
+    this.logger.debug(`Flag updated: ${key}`, updatedFlag);
+    return updatedFlag;
+  }
+  /**
+   * Deletes a feature flag from the database.
+   *
+   * @param key - Feature flag key
+   */
+  async deleteFlag(key) {
+    this.logger.log(`Deleting flag: ${key}`);
+    this.logger.debug(`Flag deleted: ${key}`);
+  }
+  /**
+   * Gets all feature flags from the database.
+   *
+   * @param environment - Filter by environment
+   * @returns List of feature flags
+   */
+  async getAllFlags(environment) {
+    this.logger.log(`Getting all flags${environment ? ` for environment: ${environment}` : ""}`);
+    const sampleFlags = this.createSampleFlags();
+    const filteredFlags = this.filterFlagsByEnvironment(sampleFlags, environment);
+    this.logger.debug(`Retrieved ${filteredFlags.length} flags`);
+    return filteredFlags;
+  }
+  /**
+   * Creates sample flags for stub implementation.
+   *
+   * @returns Array of sample feature flags
+   */
+  createSampleFlags() {
+    return [
+      {
+        key: "AUTH_GOOGLE",
+        name: "Google Authentication",
+        description: "Enable Google OAuth authentication",
+        isEnabled: true,
+        value: "true",
+        type: "boolean",
+        environment: "all",
+        rolloutPercentage: void 0,
+        createdAt: new Date(Date.now() - FeatureFlagRepository.ONE_DAY_MS),
+        updatedAt: /* @__PURE__ */ new Date(),
+        createdBy: "system",
+        updatedBy: "system"
+      },
+      {
+        key: "AUTH_DISCORD",
+        name: "Discord Authentication",
+        description: "Enable Discord OAuth authentication",
+        isEnabled: true,
+        value: "true",
+        type: "boolean",
+        environment: "all",
+        rolloutPercentage: void 0,
+        createdAt: new Date(Date.now() - FeatureFlagRepository.ONE_DAY_MS),
+        updatedAt: /* @__PURE__ */ new Date(),
+        createdBy: "system",
+        updatedBy: "system"
+      }
+    ];
+  }
+  /**
+   * Filters flags by environment.
+   *
+   * @param flags - Array of flags to filter
+   * @param environment - Environment to filter by
+   * @returns Filtered flags
+   */
+  filterFlagsByEnvironment(flags, environment) {
+    return environment ? flags.filter((flag) => flag.environment === environment || flag.environment === "all") : flags;
+  }
+  /**
+   * Gets all rules for a specific flag.
+   *
+   * @param key - Feature flag key
+   * @returns List of rules for the flag
+   */
+  async getFlagRules(key) {
+    this.logger.log(`Getting rules for flag: ${key}`);
+    const rules = [];
+    this.logger.debug(`Retrieved ${rules.length} rules for flag: ${key}`);
+    return rules;
+  }
+  /**
+   * Gets a single feature flag by key.
+   *
+   * @param key - Feature flag key
+   * @returns Feature flag or null if not found
+   */
+  async getFlagByKey(key) {
+    this.logger.log(`Getting flag by key: ${key}`);
+    return null;
+  }
+  /**
+   * Infers the type of a feature flag value.
+   *
+   * @param value - The flag value
+   * @returns Inferred type string
+   */
+  inferFlagType(value) {
+    if (typeof value === "boolean") return "boolean";
+    if (typeof value === "string") return "string";
+    if (typeof value === "number") return "number";
+    if (typeof value === "object" && value !== null) return "json";
+    return "boolean";
+  }
+  /**
+   * Maps a database row to a FeatureFlag object.
+   * This will be used when @plyaz/db is available.
+   *
+   * @param row - Database row
+   * @returns Mapped feature flag
+   */
+  // private mapRowToFlag(row: any): FeatureFlag {
+  //   return {
+  //     key: row.key,
+  //     name: row.name,
+  //     description: row.description,
+  //     isEnabled: row.is_enabled,
+  //     value: JSON.parse(row.value),
+  //     type: row.type,
+  //     environment: row.environment,
+  //     rolloutPercentage: row.rollout_percentage,
+  //     createdAt: row.created_at,
+  //     updatedAt: row.updated_at,
+  //     createdBy: row.created_by,
+  //     updatedBy: row.updated_by,
+  //   } satisfies FeatureFlag;
+  // }
+  /**
+   * Maps a database row to a FeatureFlagRule object.
+   * This will be used when @plyaz/db is available.
+   *
+   * @param row - Database row
+   * @returns Mapped feature flag rule
+   */
+  // private mapRowToRule(row: any): FeatureFlagRule {
+  //   return {
+  //     id: row.id,
+  //     flagKey: row.flag_key,
+  //     name: row.name,
+  //     description: row.description,
+  //     isEnabled: row.is_enabled,
+  //     priority: row.priority,
+  //     conditions: JSON.parse(row.conditions),
+  //     value: JSON.parse(row.value),
+  //     rolloutPercentage: row.rollout_percentage,
+  //     createdAt: row.created_at,
+  //     updatedAt: row.updated_at,
+  //     createdBy: row.created_by,
+  //     updatedBy: row.updated_by,
+  //   } satisfies FeatureFlagRule;
+  // }
+};
+__name(FeatureFlagRepository, "FeatureFlagRepository");
+// Constants for time calculations
+__publicField(FeatureFlagRepository, "ONE_DAY_MS", 864e5);
+FeatureFlagRepository = __decorateClass([
+  Injectable()
+], FeatureFlagRepository);
+
+// src/backend/featureFlags/feature-flag.module.ts
+var FeatureFlagModule = class {
+  /**
+   * Static method for importing the module with configuration.
+   * This allows customization of the feature flag system.
+   *
+   * @param options - Module configuration options
+   * @returns Configured module
+   *
+   * @example
+   * ```typescript
+   * @Module({
+   *   imports: [
+   *     FeatureFlagModule.forRoot({
+   *       provider: 'redis',
+   *       cacheEnabled: true,
+   *       cacheTtl: 600,
+   *     })
+   *   ],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRoot(options) {
+    return {
+      module: FeatureFlagModule,
+      providers: [
+        {
+          provide: "FEATURE_FLAG_CONFIG",
+          useValue: options ?? {}
+        },
+        FeatureFlagService,
+        FeatureFlagRepository
+      ],
+      exports: [FeatureFlagService, FeatureFlagRepository]
+    };
+  }
+  /**
+   * Static method for importing the module asynchronously.
+   * Useful when configuration depends on other services.
+   *
+   * @param options - Async module configuration options
+   * @returns Configured async module
+   *
+   * @example
+   * ```typescript
+   * @Module({
+   *   imports: [
+   *     FeatureFlagModule.forRootAsync({
+   *       imports: [ConfigModule],
+   *       inject: [ConfigService],
+   *       useFactory: (configService: ConfigService) => ({
+   *         provider: configService.get('FEATURE_FLAG_PROVIDER'),
+   *         cacheEnabled: configService.get('FEATURE_FLAG_CACHE_ENABLED'),
+   *       }),
+   *     })
+   *   ],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRootAsync(options) {
+    return {
+      module: FeatureFlagModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: "FEATURE_FLAG_CONFIG",
+          inject: options.inject ?? [],
+          useFactory: options.useFactory ?? (() => ({}))
+        },
+        FeatureFlagService,
+        FeatureFlagRepository
+      ],
+      exports: [FeatureFlagService, FeatureFlagRepository]
+    };
+  }
+};
+__name(FeatureFlagModule, "FeatureFlagModule");
+FeatureFlagModule = __decorateClass([
+  Global(),
+  Module({
+    controllers: [FeatureFlagController],
+    providers: [FeatureFlagService, FeatureFlagRepository],
+    exports: [FeatureFlagService, FeatureFlagRepository]
+  })
+], FeatureFlagModule);
+
+// src/backend/featureFlags/index.ts
+function FeatureFlagGuard() {
+  return function(_target, _propertyName, descriptor) {
+    return descriptor;
+  };
+}
+__name(FeatureFlagGuard, "FeatureFlagGuard");
+function FeatureFlag() {
+  return function(_target, _propertyName, descriptor) {
+    return descriptor;
+  };
+}
+__name(FeatureFlag, "FeatureFlag");
+var FeatureFlagContext = createContext(
+  null
+);
+function FeatureFlagAppProvider({
+  config,
+  // defaultContext: _defaultContext,
+  children,
+  features,
+  onReady,
+  onError,
+  isShowLoading = false,
+  loadingComponent,
+  errorComponent
+}) {
+  const [state, setState] = useState({
+    provider: null,
+    isInitialized: false,
+    isLoading: true,
+    error: null,
+    lastUpdated: null
+  });
+  const isMountedRef = useRef(true);
+  const initializeProvider = useCallback(async () => {
+    try {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      const provider = FeatureFlagProviderFactory.create(config, features);
+      await provider.initialize();
+      if (isMountedRef.current) {
+        setState({
+          provider,
+          isInitialized: true,
+          isLoading: false,
+          error: null,
+          lastUpdated: /* @__PURE__ */ new Date()
+        });
+        onReady?.(provider);
+      }
+    } catch (error) {
+      const errorObj = error instanceof Error ? error : new Error("Failed to initialize feature flags");
+      if (isMountedRef.current) {
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: errorObj
+        }));
+        onError?.(errorObj);
+      }
+    }
+  }, [config, onReady, onError]);
+  const refresh = useCallback(async () => {
+    if (!state.provider) {
+      await initializeProvider();
+      return;
+    }
+    try {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      await state.provider.refresh();
+      if (isMountedRef.current) {
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          lastUpdated: /* @__PURE__ */ new Date()
+        }));
+      }
+    } catch (error) {
+      const errorObj = error instanceof Error ? error : new Error("Failed to refresh feature flags");
+      if (isMountedRef.current) {
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: errorObj
+        }));
+        onError?.(errorObj);
+      }
+    }
+  }, [state.provider, initializeProvider, onError]);
+  useEffect(() => {
+    void initializeProvider();
+  }, [initializeProvider]);
+  useEffect(() => {
+    if (!state.provider) return;
+    const unsubscribe = state.provider.subscribe(() => {
+      if (isMountedRef.current) {
+        setState((prev) => ({
+          ...prev,
+          lastUpdated: /* @__PURE__ */ new Date()
+        }));
+      }
+    });
+    return unsubscribe;
+  }, [state.provider]);
+  useEffect(() => {
+    return () => {
+      isMountedRef.current = false;
+      if (state.provider) {
+        state.provider.dispose();
+      }
+    };
+  }, [state.provider]);
+  if (state.isLoading && isShowLoading) {
+    if (loadingComponent) {
+      const LoadingComponent = loadingComponent;
+      return /* @__PURE__ */ jsx(LoadingComponent, {});
+    }
+    return /* @__PURE__ */ jsx("div", { children: "Loading feature flags..." });
+  }
+  if (state.error && errorComponent) {
+    const ErrorComponent = errorComponent;
+    return /* @__PURE__ */ jsx(ErrorComponent, { error: state.error, retry: initializeProvider });
+  }
+  if (!state.provider) {
+    return /* @__PURE__ */ jsx("div", { children: "Feature flag provider not available" });
+  }
+  const contextValue = {
+    provider: state.provider,
+    isInitialized: state.isInitialized,
+    isLoading: state.isLoading,
+    error: state.error,
+    lastUpdated: state.lastUpdated,
+    refresh
+  };
+  return /* @__PURE__ */ jsx(FeatureFlagContext.Provider, { value: contextValue, children });
+}
+__name(FeatureFlagAppProvider, "FeatureFlagAppProvider");
+FeatureFlagAppProvider.displayName = "FeatureFlagAppProvider";
+function createFeatureFlagProvider(config, options) {
+  return /* @__PURE__ */ __name(function withFeatureFlags(component) {
+    const WrappedComponent = /* @__PURE__ */ __name((props) => /* @__PURE__ */ jsx(
+      FeatureFlagAppProvider,
+      {
+        config,
+        features: options?.features ?? {},
+        ...options,
+        children: React.createElement(component, props)
+      }
+    ), "WrappedComponent");
+    WrappedComponent.displayName = `withFeatureFlags(${component.displayName ?? component.name})`;
+    return WrappedComponent;
+  }, "withFeatureFlags");
+}
+__name(createFeatureFlagProvider, "createFeatureFlagProvider");
+function useFeatureFlagProvider() {
+  const context = useContext(FeatureFlagContext);
+  if (!context) {
+    throw new Error(
+      "useFeatureFlagProvider must be used within a FeatureFlagAppProvider. Make sure to wrap your component tree with <FeatureFlagAppProvider>."
+    );
+  }
+  return context.provider;
+}
+__name(useFeatureFlagProvider, "useFeatureFlagProvider");
+function useFeatureFlagProviderStatus() {
+  const context = useContext(FeatureFlagContext);
+  if (!context) {
+    throw new Error(
+      "useFeatureFlagProviderStatus must be used within a FeatureFlagProvider. Make sure to wrap your component tree with <FeatureFlagAppProvider>."
+    );
+  }
+  return {
+    isInitialized: context.isInitialized,
+    isLoading: context.isLoading,
+    error: context.error,
+    lastUpdated: context.lastUpdated
+  };
+}
+__name(useFeatureFlagProviderStatus, "useFeatureFlagProviderStatus");
+function createEvaluationFunction(params, setState) {
+  const { provider, key, context, defaultValue } = params;
+  return async () => {
+    if (!provider) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const evaluation = await provider.getFlag(key, context);
+      setState((prev) => ({
+        ...prev,
+        value: evaluation?.value ?? defaultValue ?? false,
+        isLoading: false,
+        error: null,
+        evaluation
+      }));
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        value: defaultValue ?? false,
+        isLoading: false,
+        error: error instanceof Error ? error : new Error("Evaluation failed"),
+        evaluation: null
+      }));
+    }
+  };
+}
+__name(createEvaluationFunction, "createEvaluationFunction");
+function useFeatureFlagEvaluation(key, context, defaultValue, provider) {
+  const [state, setState] = useState({
+    value: defaultValue ?? false,
+    isLoading: true,
+    error: null,
+    evaluation: null
+  });
+  const evaluateFlag = useCallback(
+    createEvaluationFunction({ provider, key, context, defaultValue }, setState),
+    [provider, key, context, defaultValue]
+  );
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      void evaluateFlag();
+    }, 0);
+    return () => clearTimeout(timer);
+  }, [evaluateFlag]);
+  return {
+    value: state.value,
+    isLoading: state.isLoading,
+    error: state.error,
+    refresh: evaluateFlag
+  };
+}
+__name(useFeatureFlagEvaluation, "useFeatureFlagEvaluation");
+function useMultipleFeatureFlagsEvaluation(keys, context, defaultValue, provider) {
+  const [flagStates, setFlagStates] = useState(() => {
+    const initialStates = {};
+    keys.forEach((key) => {
+      initialStates[key] = {
+        value: defaultValue,
+        isLoading: true,
+        error: null,
+        evaluation: null
+      };
+    });
+    return initialStates;
+  });
+  const evaluateFlags = useCallback(async () => {
+    if (!provider) return;
+    setFlagStates((prevStates) => {
+      const newStates = { ...prevStates };
+      keys.forEach((key) => {
+        newStates[key] = {
+          ...newStates[key],
+          isLoading: true,
+          error: null
+        };
+      });
+      return newStates;
+    });
+    const evaluations = await Promise.allSettled(
+      keys.map(async (key) => {
+        try {
+          const evaluation = await provider.getFlag(key, context);
+          return { key, evaluation, error: null };
+        } catch (error) {
+          return {
+            key,
+            evaluation: null,
+            error: error instanceof Error ? error : new Error("Evaluation failed")
+          };
+        }
+      })
+    );
+    setFlagStates((prevStates) => {
+      const newStates = { ...prevStates };
+      evaluations.forEach((result, index) => {
+        const key = keys[index];
+        if (result.status === "fulfilled") {
+          const { evaluation, error } = result.value;
+          newStates[key] = {
+            value: evaluation?.value ?? defaultValue,
+            isLoading: false,
+            error,
+            evaluation
+          };
+        }
+      });
+      return newStates;
+    });
+  }, [keys, provider, context, defaultValue]);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      void evaluateFlags();
+    }, 0);
+    return () => clearTimeout(timer);
+  }, [evaluateFlags]);
+  const refreshFunctions = useMemo(() => {
+    const refreshFns = {};
+    keys.forEach((key) => {
+      refreshFns[key] = async () => {
+        if (!provider) return;
+        setFlagStates((prev) => ({
+          ...prev,
+          [key]: { ...prev[key], isLoading: true, error: null }
+        }));
+        try {
+          const evaluation = await provider.getFlag(key, context);
+          setFlagStates((prev) => ({
+            ...prev,
+            [key]: {
+              value: evaluation?.value ?? defaultValue,
+              isLoading: false,
+              error: null,
+              evaluation
+            }
+          }));
+        } catch (error) {
+          setFlagStates((prev) => ({
+            ...prev,
+            [key]: {
+              value: defaultValue,
+              isLoading: false,
+              error: error instanceof Error ? error : new Error("Evaluation failed"),
+              evaluation: null
+            }
+          }));
+        }
+      };
+    });
+    return refreshFns;
+  }, [keys, provider, context, defaultValue]);
+  return useMemo(() => {
+    const result = {};
+    keys.forEach((key) => {
+      const state = flagStates[key] ?? {
+        value: defaultValue,
+        isLoading: true,
+        error: null};
+      result[key] = {
+        value: state.value,
+        isLoading: state.isLoading,
+        error: state.error,
+        refresh: refreshFunctions[key] ?? (async () => {
+        })
+      };
+    });
+    return result;
+  }, [keys, flagStates, refreshFunctions, defaultValue]);
+}
+__name(useMultipleFeatureFlagsEvaluation, "useMultipleFeatureFlagsEvaluation");
+
+// src/frontend/featureFlags/hooks/useFeatureFlag.ts
+function useFeatureFlag(key, options = {}) {
+  const { context, isAutoRefresh = true, defaultValue, isSuspense = false } = options;
+  const provider = useFeatureFlagProvider();
+  const {
+    value,
+    isLoading,
+    error,
+    refresh: evaluateFlag
+  } = useFeatureFlagEvaluation(
+    key,
+    context,
+    defaultValue,
+    provider
+  );
+  const refresh = useCallback(async () => {
+    await evaluateFlag();
+  }, [evaluateFlag]);
+  useEffect(() => {
+    if (!provider || !isAutoRefresh) return;
+    const unsubscribe = provider.subscribe(() => {
+      void evaluateFlag();
+    });
+    return unsubscribe;
+  }, [provider, isAutoRefresh, evaluateFlag]);
+  if (isSuspense && isLoading) {
+    throw evaluateFlag();
+  }
+  return {
+    value,
+    isLoading,
+    error,
+    refresh
+  };
+}
+__name(useFeatureFlag, "useFeatureFlag");
+function useFeatureFlagEnabled(key, options = {}) {
+  const { value } = useFeatureFlag(key, {
+    ...options,
+    defaultValue: options.defaultValue ?? false
+  });
+  return value;
+}
+__name(useFeatureFlagEnabled, "useFeatureFlagEnabled");
+function useFeatureFlagValue(key, options = {}) {
+  const { value } = useFeatureFlag(key, options);
+  return value;
+}
+__name(useFeatureFlagValue, "useFeatureFlagValue");
+function useMultipleFeatureFlags(keys, options = {}) {
+  const provider = useFeatureFlagProvider();
+  const { context, isAutoRefresh = true, defaultValue = false } = options;
+  const flagStates = useMultipleFeatureFlagsEvaluation(keys, context, defaultValue, provider);
+  useEffect(() => {
+    if (!provider || !isAutoRefresh) return;
+    const unsubscribe = provider.subscribe(() => {
+      keys.forEach((key) => {
+        if (typeof flagStates[key]?.refresh === "function") {
+          void flagStates[key].refresh();
+        }
+      });
+    });
+    return unsubscribe;
+  }, [provider, isAutoRefresh, flagStates, keys]);
+  return flagStates;
+}
+__name(useMultipleFeatureFlags, "useMultipleFeatureFlags");
+function useFeatureFlagHelpers() {
+  const provider = useFeatureFlagProvider();
+  const setOverride = useCallback(
+    (key, value) => {
+      provider.setOverride(key, value);
+    },
+    [provider]
+  );
+  const removeOverride = useCallback(
+    (key) => {
+      provider.removeOverride(key);
+    },
+    [provider]
+  );
+  const clearOverrides = useCallback(() => {
+    provider.clearOverrides();
+  }, [provider]);
+  const refresh = useCallback(async () => {
+    await provider.refresh();
+  }, [provider]);
+  const getMultipleFlags = useCallback(
+    async (keys, context) => {
+      const results = {};
+      await Promise.all(
+        keys.map(async (key) => {
+          const evaluation = await provider.getFlag(key, context);
+          results[key] = evaluation.value;
+        })
+      );
+      return results;
+    },
+    [provider]
+  );
+  const isAnyEnabled = useCallback(
+    async (keys, context) => {
+      const evaluations = await Promise.all(keys.map((key) => provider.isEnabled(key, context)));
+      return evaluations.some((enabled) => enabled);
+    },
+    [provider]
+  );
+  const isAllEnabled = useCallback(
+    async (keys, context) => {
+      const evaluations = await Promise.all(keys.map((key) => provider.isEnabled(key, context)));
+      return evaluations.every((enabled) => enabled);
+    },
+    [provider]
+  );
+  const whenEnabled = useCallback(
+    async (key, callback, fallback, context) => {
+      const isEnabled = await provider.isEnabled(key, context);
+      if (isEnabled) {
+        return callback();
+      } else if (fallback) {
+        return fallback();
+      }
+      return void 0;
+    },
+    [provider]
+  );
+  return useMemo(
+    () => ({
+      setOverride,
+      removeOverride,
+      clearOverrides,
+      refresh,
+      getMultipleFlags,
+      isAnyEnabled,
+      isAllEnabled,
+      whenEnabled
+    }),
+    [
+      setOverride,
+      removeOverride,
+      clearOverrides,
+      refresh,
+      getMultipleFlags,
+      isAnyEnabled,
+      isAllEnabled,
+      whenEnabled
+    ]
+  );
+}
+__name(useFeatureFlagHelpers, "useFeatureFlagHelpers");
+
+export { ApiFeatureFlagProvider, CacheManager, ConditionUtils, ContextUtils, DEFAULT_FEATURE_FLAG_CONFIG, DatabaseFeatureFlagProvider, FeatureFlag, FeatureFlagAppProvider, FeatureFlagContext, FeatureFlagContextBuilder, FeatureFlagController, FeatureFlagEngine, FeatureFlagGuard, FeatureFlagModule, FeatureFlagProvider, FeatureFlagProviderFactory, FeatureFlagRepository, FeatureFlagService, FeatureFlagSystem, FileFeatureFlagProvider, HashUtils, MemoryFeatureFlagProvider, RedisFeatureFlagProvider, ValueUtils, createBackendContext, createFeatureFlagProvider, createFrontendContext, createRolloutIdentifier, evaluateArrayOperator, evaluateConditionOperator, evaluateEqualityOperator, evaluateNumericOperator, evaluateStringOperator, hashString, isArrayOperator, isEqualityOperator, isInRollout, isNumericOperator, isStringOperator, isTruthy, toBoolean, useFeatureFlag, useFeatureFlagEnabled, useFeatureFlagHelpers, useFeatureFlagProvider, useFeatureFlagProviderStatus, useFeatureFlagValue, useMultipleFeatureFlags };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map