@nestarc/feature-flag 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nestarc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,509 @@
+# @nestarc/feature-flag
+
+DB-backed feature flags for NestJS + Prisma + PostgreSQL -- tenant-aware overrides, percentage rollouts, and zero external dependencies.
+
+## Features
+
+- **Database-backed** -- flags stored in PostgreSQL via Prisma, no external service required
+- **Tenant / user / environment overrides** -- granular control per tenant, user, or deployment environment
+- **Percentage rollouts** -- deterministic hashing (murmurhash3) for consistent per-user bucketing
+- **Guard decorator** -- `@FeatureFlag()` automatically gates routes and controllers
+- **Bypass decorator** -- `@BypassFeatureFlag()` exempts health checks and public endpoints
+- **Programmatic evaluation** -- `isEnabled()` and `evaluateAll()` for service-layer logic
+- **Built-in caching** -- configurable TTL with manual invalidation
+- **Event system** -- optional integration with `@nestjs/event-emitter` for audit and observability
+- **Testing utilities** -- drop-in `TestFeatureFlagModule` for unit and integration tests
+
+## Installation
+
+```bash
+npm install @nestarc/feature-flag
+```
+
+### Peer dependencies
+
+```bash
+npm install @nestjs/common @nestjs/core @prisma/client rxjs reflect-metadata
+```
+
+### Optional
+
+```bash
+# Required only if you enable emitEvents
+npm install @nestjs/event-emitter
+```
+
+## Prisma Schema
+
+Add the following models to your `schema.prisma`:
+
+```prisma
+model FeatureFlag {
+  id          String    @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  key         String    @unique
+  description String?
+  enabled     Boolean   @default(false)
+  percentage  Int       @default(0)
+  metadata    Json      @default("{}")
+  archivedAt  DateTime? @map("archived_at") @db.Timestamptz()
+  createdAt   DateTime  @default(now()) @map("created_at") @db.Timestamptz()
+  updatedAt   DateTime  @updatedAt @map("updated_at") @db.Timestamptz()
+
+  overrides FeatureFlagOverride[]
+
+  @@map("feature_flags")
+}
+
+model FeatureFlagOverride {
+  id          String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  flagId      String   @map("flag_id") @db.Uuid
+  tenantId    String?  @map("tenant_id")
+  userId      String?  @map("user_id")
+  environment String?
+  enabled     Boolean
+  createdAt   DateTime @default(now()) @map("created_at") @db.Timestamptz()
+  updatedAt   DateTime @updatedAt @map("updated_at") @db.Timestamptz()
+
+  flag FeatureFlag @relation(fields: [flagId], references: [id], onDelete: Cascade)
+
+  @@index([flagId], map: "idx_override_flag_id")
+  @@map("feature_flag_overrides")
+}
+```
+
+### Partial unique indexes for overrides
+
+PostgreSQL treats `NULL != NULL` in standard unique constraints, which means a simple `UNIQUE(flag_id, tenant_id, user_id, environment)` would allow duplicate rows when any nullable column is `NULL`. To enforce true uniqueness across all combinations, apply the following migration that creates one partial index per NULL/NOT-NULL pattern:
+
+```sql
+-- Drop the old unique constraint that does not handle NULLs correctly
+ALTER TABLE feature_flag_overrides
+  DROP CONSTRAINT IF EXISTS uq_override_context;
+
+-- Global override (all nullable columns NULL)
+CREATE UNIQUE INDEX uq_override_000
+  ON feature_flag_overrides (flag_id)
+  WHERE tenant_id IS NULL AND user_id IS NULL AND environment IS NULL;
+
+-- Only environment is NOT NULL
+CREATE UNIQUE INDEX uq_override_001
+  ON feature_flag_overrides (flag_id, environment)
+  WHERE tenant_id IS NULL AND user_id IS NULL AND environment IS NOT NULL;
+
+-- Only user_id is NOT NULL
+CREATE UNIQUE INDEX uq_override_010
+  ON feature_flag_overrides (flag_id, user_id)
+  WHERE tenant_id IS NULL AND user_id IS NOT NULL AND environment IS NULL;
+
+-- user_id + environment
+CREATE UNIQUE INDEX uq_override_011
+  ON feature_flag_overrides (flag_id, user_id, environment)
+  WHERE tenant_id IS NULL AND user_id IS NOT NULL AND environment IS NOT NULL;
+
+-- Only tenant_id is NOT NULL
+CREATE UNIQUE INDEX uq_override_100
+  ON feature_flag_overrides (flag_id, tenant_id)
+  WHERE tenant_id IS NOT NULL AND user_id IS NULL AND environment IS NULL;
+
+-- tenant_id + environment
+CREATE UNIQUE INDEX uq_override_101
+  ON feature_flag_overrides (flag_id, tenant_id, environment)
+  WHERE tenant_id IS NOT NULL AND user_id IS NULL AND environment IS NOT NULL;
+
+-- tenant_id + user_id
+CREATE UNIQUE INDEX uq_override_110
+  ON feature_flag_overrides (flag_id, tenant_id, user_id)
+  WHERE tenant_id IS NOT NULL AND user_id IS NOT NULL AND environment IS NULL;
+
+-- All three NOT NULL
+CREATE UNIQUE INDEX uq_override_111
+  ON feature_flag_overrides (flag_id, tenant_id, user_id, environment)
+  WHERE tenant_id IS NOT NULL AND user_id IS NOT NULL AND environment IS NOT NULL;
+```
+
+This SQL is included in the initial migration at `prisma/migrations/20260405000000_init/migration.sql`.
+
+## Module Registration
+
+### forRoot (synchronous)
+
+```typescript
+import { FeatureFlagModule } from '@nestarc/feature-flag';
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRoot({
+      environment: 'production',
+      prisma: prismaService,
+      userIdExtractor: (req) => req.headers['x-user-id'] as string,
+      emitEvents: true,
+      cacheTtlMs: 30_000,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### forRootAsync (with useFactory)
+
+```typescript
+import { FeatureFlagModule } from '@nestarc/feature-flag';
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService, PrismaService],
+      useFactory: (config: ConfigService, prisma: PrismaService) => ({
+        environment: config.get('NODE_ENV'),
+        prisma,
+        userIdExtractor: (req) => req.headers['x-user-id'] as string,
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### forRootAsync (with useClass)
+
+```typescript
+@Injectable()
+class FeatureFlagConfigService implements FeatureFlagModuleOptionsFactory {
+  constructor(
+    private readonly config: ConfigService,
+    private readonly prisma: PrismaService,
+  ) {}
+
+  createFeatureFlagOptions() {
+    return {
+      environment: this.config.get('NODE_ENV'),
+      prisma: this.prisma,
+    };
+  }
+}
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRootAsync({
+      imports: [ConfigModule, PrismaModule],
+      useClass: FeatureFlagConfigService,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### forRootAsync (with useExisting)
+
+```typescript
+@Module({
+  imports: [
+    FeatureFlagModule.forRootAsync({
+      useExisting: FeatureFlagConfigService,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## Feature Flag Guard
+
+The `@FeatureFlag()` decorator automatically applies `UseGuards(FeatureFlagGuard)`, so you do not need to add `@UseGuards()` yourself.
+
+### Method-level
+
+```typescript
+import { FeatureFlag } from '@nestarc/feature-flag';
+
+@Controller('dashboard')
+export class DashboardController {
+  @FeatureFlag('NEW_DASHBOARD')
+  @Get()
+  getDashboard() {
+    return { message: 'Welcome to the new dashboard' };
+  }
+}
+```
+
+### Class-level
+
+```typescript
+@FeatureFlag('BETA_API')
+@Controller('beta')
+export class BetaController {
+  @Get('feature-a')
+  featureA() { /* guarded */ }
+
+  @Get('feature-b')
+  featureB() { /* guarded */ }
+}
+```
+
+### Custom status code and fallback
+
+```typescript
+@FeatureFlag('PREMIUM_FEATURE', {
+  statusCode: 402,
+  fallback: { message: 'Upgrade required' },
+})
+@Get('premium')
+getPremiumContent() { ... }
+```
+
+When the flag is disabled, the guard responds with the given `statusCode` (default `403`) and optional `fallback` body.
+
+### Bypassing the guard
+
+Use `@BypassFeatureFlag()` on methods that should always be accessible, even when a class-level flag is applied:
+
+```typescript
+import { BypassFeatureFlag } from '@nestarc/feature-flag';
+
+@FeatureFlag('BETA_API')
+@Controller('beta')
+export class BetaController {
+  @Get('docs')
+  betaDocs() { /* guarded by BETA_API */ }
+
+  @BypassFeatureFlag()
+  @Get('health')
+  healthCheck() {
+    return { status: 'ok' };
+  }
+}
+```
+
+## Programmatic Evaluation
+
+Inject `FeatureFlagService` for service-layer checks outside the HTTP request cycle:
+
+```typescript
+import { FeatureFlagService } from '@nestarc/feature-flag';
+
+@Injectable()
+export class PaymentService {
+  constructor(private readonly flags: FeatureFlagService) {}
+
+  async processPayment(order: Order) {
+    const useNewGateway = await this.flags.isEnabled('NEW_PAYMENT_GATEWAY');
+
+    if (useNewGateway) {
+      return this.newGateway.process(order);
+    }
+    return this.legacyGateway.process(order);
+  }
+}
+```
+
+### Evaluate all flags at once
+
+```typescript
+const allFlags = await this.flags.evaluateAll();
+// { NEW_DASHBOARD: true, PREMIUM_FEATURE: false, ... }
+```
+
+### Explicit evaluation context
+
+Both `isEnabled()` and `evaluateAll()` accept an optional `EvaluationContext` to override the auto-detected context:
+
+```typescript
+const enabled = await this.flags.isEnabled('MY_FLAG', {
+  userId: 'user-123',
+  tenantId: 'tenant-abc',
+  environment: 'staging',
+});
+```
+
+Passing `null` explicitly clears that dimension, suppressing any ambient value from the request context:
+
+```typescript
+// Evaluate as if no user is present, even within a request with x-user-id
+const globalResult = await this.flags.isEnabled('MY_FLAG', { userId: null });
+```
+
+## Overrides
+
+Set context-specific overrides that take precedence over the global flag value:
+
+```typescript
+// Enable for a specific tenant
+await this.flags.setOverride('MY_FLAG', {
+  tenantId: 'tenant-1',
+  enabled: true,
+});
+
+// Disable for a specific user
+await this.flags.setOverride('MY_FLAG', {
+  userId: 'user-42',
+  enabled: false,
+});
+
+// Enable only in staging
+await this.flags.setOverride('MY_FLAG', {
+  environment: 'staging',
+  enabled: true,
+});
+
+// Combine dimensions
+await this.flags.setOverride('MY_FLAG', {
+  tenantId: 'tenant-1',
+  userId: 'user-42',
+  environment: 'production',
+  enabled: true,
+});
+```
+
+## Events
+
+Enable event emission to observe flag lifecycle changes. Requires `@nestjs/event-emitter` as an optional peer dependency.
+
+**Important:** You must import `EventEmitterModule.forRoot()` in your app module. The feature-flag module reuses the same `EventEmitter2` singleton that NestJS manages, so `@OnEvent()` listeners work out of the box.
+
+### Setup
+
+```typescript
+import { EventEmitterModule } from '@nestjs/event-emitter';
+
+@Module({
+  imports: [
+    EventEmitterModule.forRoot(),   // must be imported
+    FeatureFlagModule.forRoot({
+      environment: 'production',
+      prisma: prismaService,
+      emitEvents: true,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Event types
+
+| Event constant                           | Event string                       | Payload type         |
+| ---------------------------------------- | ---------------------------------- | -------------------- |
+| `FeatureFlagEvents.EVALUATED`            | `feature-flag.evaluated`           | `FlagEvaluatedEvent` |
+| `FeatureFlagEvents.CREATED`              | `feature-flag.created`             | `FlagMutationEvent`  |
+| `FeatureFlagEvents.UPDATED`              | `feature-flag.updated`             | `FlagMutationEvent`  |
+| `FeatureFlagEvents.ARCHIVED`             | `feature-flag.archived`            | `FlagMutationEvent`  |
+| `FeatureFlagEvents.OVERRIDE_SET`         | `feature-flag.override.set`        | `FlagOverrideEvent`  |
+| `FeatureFlagEvents.OVERRIDE_REMOVED`     | `feature-flag.override.removed`    | `FlagOverrideEvent`  |
+| `FeatureFlagEvents.CACHE_INVALIDATED`    | `feature-flag.cache.invalidated`   | `{}`                 |
+
+### Listening to events
+
+```typescript
+import { OnEvent } from '@nestjs/event-emitter';
+import { FeatureFlagEvents, FlagEvaluatedEvent } from '@nestarc/feature-flag';
+
+@Injectable()
+export class FlagAuditListener {
+  @OnEvent(FeatureFlagEvents.EVALUATED)
+  handleEvaluation(event: FlagEvaluatedEvent) {
+    console.log(`Flag ${event.flagKey} = ${event.result} (source: ${event.source})`);
+  }
+}
+```
+
+## Testing
+
+Import `TestFeatureFlagModule` from the `/testing` subpath to stub flag values in tests without a database connection:
+
+```typescript
+import { TestFeatureFlagModule } from '@nestarc/feature-flag/testing';
+
+describe('DashboardController', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      imports: [
+        TestFeatureFlagModule.register({
+          NEW_DASHBOARD: true,
+          PREMIUM_FEATURE: false,
+        }),
+      ],
+      controllers: [DashboardController],
+    }).compile();
+
+    app = module.createNestApplication();
+    await app.init();
+  });
+
+  it('should allow access when flag is enabled', () => {
+    return request(app.getHttpServer())
+      .get('/dashboard')
+      .expect(200);
+  });
+});
+```
+
+`TestFeatureFlagModule.register()` provides a global mock of `FeatureFlagService` where `isEnabled(key)` returns the boolean you specified (defaulting to `false` for unregistered keys) and `evaluateAll()` returns the full map.
+
+## Evaluation Priority
+
+When `isEnabled()` is called, flags are evaluated through a 6-layer cascade. The first matching layer wins:
+
+| Priority | Layer                  | Description                                                        |
+| -------- | ---------------------- | ------------------------------------------------------------------ |
+| 1        | **Archived**           | If the flag has `archivedAt` set, evaluation always returns `false` |
+| 2        | **User override**      | Override matching the current `userId` (most specific)              |
+| 3        | **Tenant override**    | Override matching the current `tenantId`                            |
+| 4        | **Environment override**| Override matching the current `environment`                        |
+| 5        | **Percentage rollout** | Deterministic hash of `flagKey + userId` (or `tenantId`) mod 100   |
+| 6        | **Global default**     | The flag's `enabled` field                                         |
+
+Percentage rollout uses murmurhash3 for deterministic bucketing: the same user always gets the same result for a given flag, ensuring a consistent experience across requests.
+
+## Configuration Reference
+
+### FeatureFlagModuleOptions
+
+| Option              | Type                              | Default   | Description                                                     |
+| ------------------- | --------------------------------- | --------- | --------------------------------------------------------------- |
+| `environment`       | `string`                          | *required*| Deployment environment (e.g. `'production'`, `'staging'`)       |
+| `cacheTtlMs`        | `number`                          | `30000`   | Cache TTL in ms. Set to `0` to disable caching                  |
+| `userIdExtractor`   | `(req: Request) => string \| null`| `undefined`| Extracts user ID from the incoming request                     |
+| `defaultOnMissing`  | `boolean`                         | `false`   | Value returned when a flag key does not exist in the database   |
+| `emitEvents`        | `boolean`                         | `false`   | Emit lifecycle events via `@nestjs/event-emitter`               |
+
+### FeatureFlagModuleRootOptions
+
+Extends `FeatureFlagModuleOptions` with:
+
+| Option  | Type  | Description                    |
+| ------- | ----- | ------------------------------ |
+| `prisma`| `any` | Prisma client instance         |
+
+## CRUD Operations
+
+`FeatureFlagService` also exposes methods for managing flags programmatically:
+
+```typescript
+// Create a flag
+const flag = await this.flags.create({
+  key: 'NEW_FEATURE',
+  description: 'Enables the new feature',
+  enabled: false,
+  percentage: 0,
+});
+
+// Update a flag
+await this.flags.update('NEW_FEATURE', {
+  enabled: true,
+  percentage: 50,
+});
+
+// Archive a flag (soft delete -- evaluations return false)
+await this.flags.archive('OLD_FEATURE');
+
+// List all active (non-archived) flags
+const allFlags = await this.flags.findAll();
+
+// Manually invalidate the cache
+this.flags.invalidateCache();
+```
+
+## License
+
+MIT

package/dist/decorators/bypass-feature-flag.decorator.d.ts

@@ -0,0 +1 @@
+export declare const BypassFeatureFlag: () => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/bypass-feature-flag.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BypassFeatureFlag = void 0;
+const common_1 = require("@nestjs/common");
+const feature_flag_constants_1 = require("../feature-flag.constants");
+const BypassFeatureFlag = () => (0, common_1.SetMetadata)(feature_flag_constants_1.BYPASS_FEATURE_FLAG_KEY, true);
+exports.BypassFeatureFlag = BypassFeatureFlag;
+//# sourceMappingURL=bypass-feature-flag.decorator.js.map

package/dist/decorators/bypass-feature-flag.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bypass-feature-flag.decorator.js","sourceRoot":"","sources":["../../src/decorators/bypass-feature-flag.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA6C;AAC7C,sEAAoE;AAE7D,MAAM,iBAAiB,GAAG,GAAG,EAAE,CAAC,IAAA,oBAAW,EAAC,gDAAuB,EAAE,IAAI,CAAC,CAAC;AAArE,QAAA,iBAAiB,qBAAoD"}

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

@@ -0,0 +1,2 @@
+import { FeatureFlagGuardOptions } from '../interfaces/feature-flag.interface';
+export declare function FeatureFlag(flagKey: string, options?: FeatureFlagGuardOptions): ClassDecorator & MethodDecorator;

package/dist/decorators/feature-flag.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlag = FeatureFlag;
+const common_1 = require("@nestjs/common");
+const feature_flag_constants_1 = require("../feature-flag.constants");
+const feature_flag_guard_1 = require("../guards/feature-flag.guard");
+function FeatureFlag(flagKey, options = {}) {
+    return (0, common_1.applyDecorators)((0, common_1.SetMetadata)(feature_flag_constants_1.FEATURE_FLAG_KEY, flagKey), (0, common_1.SetMetadata)(feature_flag_constants_1.FEATURE_FLAG_OPTIONS_KEY, options), (0, common_1.UseGuards)(feature_flag_guard_1.FeatureFlagGuard));
+}
+//# sourceMappingURL=feature-flag.decorator.js.map

package/dist/decorators/feature-flag.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.decorator.js","sourceRoot":"","sources":["../../src/decorators/feature-flag.decorator.ts"],"names":[],"mappings":";;AAKA,kCASC;AAdD,2CAAyE;AACzE,sEAAuF;AAEvF,qEAAgE;AAEhE,SAAgB,WAAW,CACzB,OAAe,EACf,UAAmC,EAAE;IAErC,OAAO,IAAA,wBAAe,EACpB,IAAA,oBAAW,EAAC,yCAAgB,EAAE,OAAO,CAAC,EACtC,IAAA,oBAAW,EAAC,iDAAwB,EAAE,OAAO,CAAC,EAC9C,IAAA,kBAAS,EAAC,qCAAgB,CAAC,CAC5B,CAAC;AACJ,CAAC"}

package/dist/events/feature-flag.events.d.ts

@@ -0,0 +1,29 @@
+import { EvaluationContext } from '../interfaces/evaluation-context.interface';
+export declare const FeatureFlagEvents: {
+    readonly EVALUATED: "feature-flag.evaluated";
+    readonly CREATED: "feature-flag.created";
+    readonly UPDATED: "feature-flag.updated";
+    readonly ARCHIVED: "feature-flag.archived";
+    readonly OVERRIDE_SET: "feature-flag.override.set";
+    readonly OVERRIDE_REMOVED: "feature-flag.override.removed";
+    readonly CACHE_INVALIDATED: "feature-flag.cache.invalidated";
+};
+export interface FlagEvaluatedEvent {
+    flagKey: string;
+    result: boolean;
+    context: EvaluationContext;
+    source: 'user_override' | 'tenant_override' | 'env_override' | 'percentage' | 'global';
+    evaluationTimeMs: number;
+}
+export interface FlagMutationEvent {
+    flagKey: string;
+    action: 'created' | 'updated' | 'archived';
+}
+export interface FlagOverrideEvent {
+    flagKey: string;
+    tenantId?: string | null;
+    userId?: string | null;
+    environment?: string | null;
+    enabled: boolean;
+    action: 'set' | 'removed';
+}

package/dist/events/feature-flag.events.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagEvents = void 0;
+exports.FeatureFlagEvents = {
+    EVALUATED: 'feature-flag.evaluated',
+    CREATED: 'feature-flag.created',
+    UPDATED: 'feature-flag.updated',
+    ARCHIVED: 'feature-flag.archived',
+    OVERRIDE_SET: 'feature-flag.override.set',
+    OVERRIDE_REMOVED: 'feature-flag.override.removed',
+    CACHE_INVALIDATED: 'feature-flag.cache.invalidated',
+};
+//# sourceMappingURL=feature-flag.events.js.map

package/dist/events/feature-flag.events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.events.js","sourceRoot":"","sources":["../../src/events/feature-flag.events.ts"],"names":[],"mappings":";;;AAEa,QAAA,iBAAiB,GAAG;IAC/B,SAAS,EAAE,wBAAwB;IACnC,OAAO,EAAE,sBAAsB;IAC/B,OAAO,EAAE,sBAAsB;IAC/B,QAAQ,EAAE,uBAAuB;IACjC,YAAY,EAAE,2BAA2B;IACzC,gBAAgB,EAAE,+BAA+B;IACjD,iBAAiB,EAAE,gCAAgC;CAC3C,CAAC"}

package/dist/feature-flag.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const FEATURE_FLAG_MODULE_OPTIONS: unique symbol;
+export declare const DEFAULT_CACHE_TTL_MS = 30000;
+export declare const FEATURE_FLAG_KEY = "FEATURE_FLAG_KEY";
+export declare const FEATURE_FLAG_OPTIONS_KEY = "FEATURE_FLAG_OPTIONS_KEY";
+export declare const BYPASS_FEATURE_FLAG_KEY = "BYPASS_FEATURE_FLAG_KEY";

package/dist/feature-flag.constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BYPASS_FEATURE_FLAG_KEY = exports.FEATURE_FLAG_OPTIONS_KEY = exports.FEATURE_FLAG_KEY = exports.DEFAULT_CACHE_TTL_MS = exports.FEATURE_FLAG_MODULE_OPTIONS = void 0;
+exports.FEATURE_FLAG_MODULE_OPTIONS = Symbol('FEATURE_FLAG_MODULE_OPTIONS');
+exports.DEFAULT_CACHE_TTL_MS = 30_000;
+exports.FEATURE_FLAG_KEY = 'FEATURE_FLAG_KEY';
+exports.FEATURE_FLAG_OPTIONS_KEY = 'FEATURE_FLAG_OPTIONS_KEY';
+exports.BYPASS_FEATURE_FLAG_KEY = 'BYPASS_FEATURE_FLAG_KEY';
+//# sourceMappingURL=feature-flag.constants.js.map

package/dist/feature-flag.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.constants.js","sourceRoot":"","sources":["../src/feature-flag.constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,2BAA2B,GAAG,MAAM,CAAC,6BAA6B,CAAC,CAAC;AAEpE,QAAA,oBAAoB,GAAG,MAAM,CAAC;AAE9B,QAAA,gBAAgB,GAAG,kBAAkB,CAAC;AACtC,QAAA,wBAAwB,GAAG,0BAA0B,CAAC;AACtD,QAAA,uBAAuB,GAAG,yBAAyB,CAAC"}

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

@@ -0,0 +1,14 @@
+import { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common';
+import { FeatureFlagModuleAsyncOptions, FeatureFlagModuleOptions } from './interfaces/feature-flag-options.interface';
+export interface FeatureFlagModuleRootOptions extends FeatureFlagModuleOptions {
+    prisma: any;
+}
+export interface FeatureFlagModuleRootAsyncOptions extends FeatureFlagModuleAsyncOptions {
+    useFactory?: (...args: any[]) => Promise<FeatureFlagModuleRootOptions> | FeatureFlagModuleRootOptions;
+}
+export declare class FeatureFlagModule implements NestModule {
+    configure(consumer: MiddlewareConsumer): void;
+    static forRoot(options: FeatureFlagModuleRootOptions): DynamicModule;
+    static forRootAsync(options: FeatureFlagModuleRootAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+}