@nestarc/feature-flag 0.1.0

package/dist/feature-flag.module.js

@@ -0,0 +1,132 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var FeatureFlagModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const feature_flag_constants_1 = require("./feature-flag.constants");
+const feature_flag_service_1 = require("./services/feature-flag.service");
+const flag_cache_service_1 = require("./services/flag-cache.service");
+const flag_evaluator_service_1 = require("./services/flag-evaluator.service");
+const flag_context_1 = require("./services/flag-context");
+const feature_flag_guard_1 = require("./guards/feature-flag.guard");
+const flag_context_middleware_1 = require("./middleware/flag-context.middleware");
+const FULL_OPTIONS = Symbol('FEATURE_FLAG_FULL_OPTIONS');
+const coreProviders = [
+    flag_cache_service_1.FlagCacheService,
+    flag_evaluator_service_1.FlagEvaluatorService,
+    flag_context_1.FlagContext,
+    feature_flag_guard_1.FeatureFlagGuard,
+    feature_flag_service_1.FeatureFlagService,
+];
+let FeatureFlagModule = FeatureFlagModule_1 = class FeatureFlagModule {
+    configure(consumer) {
+        consumer
+            .apply(flag_context_middleware_1.FlagContextMiddleware)
+            .forRoutes({ path: '(.*)', method: common_1.RequestMethod.ALL });
+    }
+    static forRoot(options) {
+        const { prisma, ...moduleOptions } = options;
+        let eventProvider = { provide: 'EVENT_EMITTER', useValue: null };
+        if (options.emitEvents) {
+            try {
+                const { EventEmitter2 } = require('@nestjs/event-emitter');
+                eventProvider = { provide: 'EVENT_EMITTER', useExisting: EventEmitter2 };
+            }
+            catch {
+                /* @nestjs/event-emitter not installed */
+            }
+        }
+        return {
+            module: FeatureFlagModule_1,
+            global: true,
+            providers: [
+                { provide: feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS, useValue: moduleOptions },
+                { provide: 'PRISMA_SERVICE', useValue: prisma },
+                eventProvider,
+                ...coreProviders,
+            ],
+            exports: [feature_flag_service_1.FeatureFlagService, flag_context_1.FlagContext, feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS],
+        };
+    }
+    static forRootAsync(options) {
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: FeatureFlagModule_1,
+            global: true,
+            imports: options.imports ?? [],
+            providers: [
+                ...asyncProviders,
+                {
+                    provide: feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS,
+                    useFactory: ({ prisma: _, ...moduleOptions }) => moduleOptions,
+                    inject: [FULL_OPTIONS],
+                },
+                {
+                    provide: 'PRISMA_SERVICE',
+                    useFactory: (full) => full.prisma,
+                    inject: [FULL_OPTIONS],
+                },
+                {
+                    provide: 'EVENT_EMITTER',
+                    useFactory: (full, moduleRef) => {
+                        if (!full.emitEvents)
+                            return null;
+                        try {
+                            const { EventEmitter2 } = require('@nestjs/event-emitter');
+                            return moduleRef.get(EventEmitter2, { strict: false });
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                    inject: [FULL_OPTIONS, core_1.ModuleRef],
+                },
+                ...coreProviders,
+            ],
+            exports: [feature_flag_service_1.FeatureFlagService, flag_context_1.FlagContext, feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: FULL_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject ?? [],
+                },
+            ];
+        }
+        if (options.useClass) {
+            return [
+                { provide: options.useClass, useClass: options.useClass },
+                {
+                    provide: FULL_OPTIONS,
+                    useFactory: (factory) => factory.createFeatureFlagOptions(),
+                    inject: [options.useClass],
+                },
+            ];
+        }
+        if (options.useExisting) {
+            return [
+                {
+                    provide: FULL_OPTIONS,
+                    useFactory: (factory) => factory.createFeatureFlagOptions(),
+                    inject: [options.useExisting],
+                },
+            ];
+        }
+        return [];
+    }
+};
+exports.FeatureFlagModule = FeatureFlagModule;
+exports.FeatureFlagModule = FeatureFlagModule = FeatureFlagModule_1 = __decorate([
+    (0, common_1.Module)({})
+], FeatureFlagModule);
+//# sourceMappingURL=feature-flag.module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.module.js","sourceRoot":"","sources":["../src/feature-flag.module.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { FeatureFlagService } from '../services/feature-flag.service';
+export declare class FeatureFlagGuard implements CanActivate {
+    private readonly reflector;
+    private readonly featureFlagService;
+    constructor(reflector: Reflector, featureFlagService: FeatureFlagService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/guards/feature-flag.guard.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const feature_flag_service_1 = require("../services/feature-flag.service");
+const feature_flag_constants_1 = require("../feature-flag.constants");
+let FeatureFlagGuard = class FeatureFlagGuard {
+    constructor(reflector, featureFlagService) {
+        this.reflector = reflector;
+        this.featureFlagService = featureFlagService;
+    }
+    async canActivate(context) {
+        const handler = context.getHandler();
+        const classRef = context.getClass();
+        // Check bypass
+        const bypass = this.reflector.get(feature_flag_constants_1.BYPASS_FEATURE_FLAG_KEY, handler) ||
+            this.reflector.get(feature_flag_constants_1.BYPASS_FEATURE_FLAG_KEY, classRef);
+        if (bypass)
+            return true;
+        // Check flag key (handler-level first, then class-level)
+        const flagKey = this.reflector.get(feature_flag_constants_1.FEATURE_FLAG_KEY, handler) ??
+            this.reflector.get(feature_flag_constants_1.FEATURE_FLAG_KEY, classRef);
+        if (!flagKey)
+            return true;
+        const options = this.reflector.get(feature_flag_constants_1.FEATURE_FLAG_OPTIONS_KEY, handler) ??
+            this.reflector.get(feature_flag_constants_1.FEATURE_FLAG_OPTIONS_KEY, classRef) ??
+            {};
+        const enabled = await this.featureFlagService.isEnabled(flagKey);
+        if (!enabled) {
+            const statusCode = options.statusCode ?? 403;
+            const body = options.fallback ?? { message: 'Feature not available' };
+            throw new common_1.HttpException(body, statusCode);
+        }
+        return true;
+    }
+};
+exports.FeatureFlagGuard = FeatureFlagGuard;
+exports.FeatureFlagGuard = FeatureFlagGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        feature_flag_service_1.FeatureFlagService])
+], FeatureFlagGuard);
+//# sourceMappingURL=feature-flag.guard.js.map

package/dist/guards/feature-flag.guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.guard.js","sourceRoot":"","sources":["../../src/guards/feature-flag.guard.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA0F;AAC1F,uCAAyC;AACzC,2EAAsE;AACtE,sEAImC;AAI5B,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;IAC3B,YACmB,SAAoB,EACpB,kBAAsC;QADtC,cAAS,GAAT,SAAS,CAAW;QACpB,uBAAkB,GAAlB,kBAAkB,CAAoB;IACtD,CAAC;IAEJ,KAAK,CAAC,WAAW,CAAC,OAAyB;QACzC,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;QACrC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;QAEpC,eAAe;QACf,MAAM,MAAM,GACV,IAAI,CAAC,SAAS,CAAC,GAAG,CAAU,gDAAuB,EAAE,OAAO,CAAC;YAC7D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAU,gDAAuB,EAAE,QAAQ,CAAC,CAAC;QACjE,IAAI,MAAM;YAAE,OAAO,IAAI,CAAC;QAExB,yDAAyD;QACzD,MAAM,OAAO,GACX,IAAI,CAAC,SAAS,CAAC,GAAG,CAAS,yCAAgB,EAAE,OAAO,CAAC;YACrD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAS,yCAAgB,EAAE,QAAQ,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAE1B,MAAM,OAAO,GACX,IAAI,CAAC,SAAS,CAAC,GAAG,CAA0B,iDAAwB,EAAE,OAAO,CAAC;YAC9E,IAAI,CAAC,SAAS,CAAC,GAAG,CAA0B,iDAAwB,EAAE,QAAQ,CAAC;YAC/E,EAAE,CAAC;QAEL,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAEjE,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,GAAG,CAAC;YAC7C,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,IAAI,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC;YACtE,MAAM,IAAI,sBAAa,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC5C,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAA;AArCY,4CAAgB;2BAAhB,gBAAgB;IAD5B,IAAA,mBAAU,GAAE;qCAGmB,gBAAS;QACA,yCAAkB;GAH9C,gBAAgB,CAqC5B"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { FeatureFlagModule, FeatureFlagModuleRootOptions, FeatureFlagModuleRootAsyncOptions } from './feature-flag.module';
+export { FeatureFlagService } from './services/feature-flag.service';
+export { FlagContext } from './services/flag-context';
+export { FeatureFlagGuard } from './guards/feature-flag.guard';
+export { FeatureFlag } from './decorators/feature-flag.decorator';
+export { BypassFeatureFlag } from './decorators/bypass-feature-flag.decorator';
+export { FeatureFlagModuleOptions, FeatureFlagModuleAsyncOptions, FeatureFlagModuleOptionsFactory, } from './interfaces/feature-flag-options.interface';
+export { EvaluationContext } from './interfaces/evaluation-context.interface';
+export { CreateFeatureFlagInput, UpdateFeatureFlagInput, SetOverrideInput, FeatureFlagGuardOptions, FeatureFlagWithOverrides, FlagOverride, } from './interfaces/feature-flag.interface';
+export { FeatureFlagEvents, FlagEvaluatedEvent, FlagMutationEvent, FlagOverrideEvent, } from './events/feature-flag.events';
+export { FEATURE_FLAG_MODULE_OPTIONS } from './feature-flag.constants';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURE_FLAG_MODULE_OPTIONS = exports.FeatureFlagEvents = exports.BypassFeatureFlag = exports.FeatureFlag = exports.FeatureFlagGuard = exports.FlagContext = exports.FeatureFlagService = exports.FeatureFlagModule = void 0;
+// Module
+var feature_flag_module_1 = require("./feature-flag.module");
+Object.defineProperty(exports, "FeatureFlagModule", { enumerable: true, get: function () { return feature_flag_module_1.FeatureFlagModule; } });
+// Services
+var feature_flag_service_1 = require("./services/feature-flag.service");
+Object.defineProperty(exports, "FeatureFlagService", { enumerable: true, get: function () { return feature_flag_service_1.FeatureFlagService; } });
+var flag_context_1 = require("./services/flag-context");
+Object.defineProperty(exports, "FlagContext", { enumerable: true, get: function () { return flag_context_1.FlagContext; } });
+// Guard
+var feature_flag_guard_1 = require("./guards/feature-flag.guard");
+Object.defineProperty(exports, "FeatureFlagGuard", { enumerable: true, get: function () { return feature_flag_guard_1.FeatureFlagGuard; } });
+// Decorators
+var feature_flag_decorator_1 = require("./decorators/feature-flag.decorator");
+Object.defineProperty(exports, "FeatureFlag", { enumerable: true, get: function () { return feature_flag_decorator_1.FeatureFlag; } });
+var bypass_feature_flag_decorator_1 = require("./decorators/bypass-feature-flag.decorator");
+Object.defineProperty(exports, "BypassFeatureFlag", { enumerable: true, get: function () { return bypass_feature_flag_decorator_1.BypassFeatureFlag; } });
+// Events
+var feature_flag_events_1 = require("./events/feature-flag.events");
+Object.defineProperty(exports, "FeatureFlagEvents", { enumerable: true, get: function () { return feature_flag_events_1.FeatureFlagEvents; } });
+// Constants
+var feature_flag_constants_1 = require("./feature-flag.constants");
+Object.defineProperty(exports, "FEATURE_FLAG_MODULE_OPTIONS", { enumerable: true, get: function () { return feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,SAAS;AACT,6DAA2H;AAAlH,wHAAA,iBAAiB,OAAA;AAE1B,WAAW;AACX,wEAAqE;AAA5D,0HAAA,kBAAkB,OAAA;AAC3B,wDAAsD;AAA7C,2GAAA,WAAW,OAAA;AAEpB,QAAQ;AACR,kEAA+D;AAAtD,sHAAA,gBAAgB,OAAA;AAEzB,aAAa;AACb,8EAAkE;AAAzD,qHAAA,WAAW,OAAA;AACpB,4FAA+E;AAAtE,kIAAA,iBAAiB,OAAA;AAkB1B,SAAS;AACT,oEAKsC;AAJpC,wHAAA,iBAAiB,OAAA;AAMnB,YAAY;AACZ,mEAAuE;AAA9D,qIAAA,2BAA2B,OAAA"}

package/dist/interfaces/evaluation-context.interface.d.ts

@@ -0,0 +1,8 @@
+export interface EvaluationContext {
+    /** User ID — used for user overrides and percentage hash */
+    userId?: string | null;
+    /** Tenant ID — used for tenant overrides. Ignored if tenancy is not installed */
+    tenantId?: string | null;
+    /** Environment — auto-injected from module options. Can be explicitly overridden */
+    environment?: string;
+}

package/dist/interfaces/evaluation-context.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=evaluation-context.interface.js.map

package/dist/interfaces/evaluation-context.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-context.interface.js","sourceRoot":"","sources":["../../src/interfaces/evaluation-context.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/feature-flag-options.interface.d.ts

@@ -0,0 +1,27 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+import { Request } from 'express';
+export interface FeatureFlagModuleOptions {
+    /** Current environment (e.g., 'development', 'staging', 'production') */
+    environment: string;
+    /** Cache TTL in milliseconds. 0 disables caching. Default: 30000 */
+    cacheTtlMs?: number;
+    /** Extract user ID from request. Returns null if user is not authenticated. */
+    userIdExtractor?: (req: Request) => string | null;
+    /** Default value when evaluating a non-existent flag. Default: false */
+    defaultOnMissing?: boolean;
+    /** Emit evaluation events via @nestjs/event-emitter. Default: false */
+    emitEvents?: boolean;
+}
+export interface FeatureFlagModuleOptionsFactory {
+    createFeatureFlagOptions(): Promise<FeatureFlagModuleOptions & {
+        prisma: any;
+    }> | (FeatureFlagModuleOptions & {
+        prisma: any;
+    });
+}
+export interface FeatureFlagModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<FeatureFlagModuleOptions> | FeatureFlagModuleOptions;
+    useClass?: Type<FeatureFlagModuleOptionsFactory>;
+    useExisting?: Type<FeatureFlagModuleOptionsFactory>;
+}

package/dist/interfaces/feature-flag-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=feature-flag-options.interface.js.map

package/dist/interfaces/feature-flag-options.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag-options.interface.js","sourceRoot":"","sources":["../../src/interfaces/feature-flag-options.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/feature-flag.interface.d.ts

@@ -0,0 +1,45 @@
+export interface CreateFeatureFlagInput {
+    key: string;
+    description?: string;
+    enabled?: boolean;
+    percentage?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateFeatureFlagInput {
+    description?: string;
+    enabled?: boolean;
+    percentage?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SetOverrideInput {
+    tenantId?: string;
+    userId?: string;
+    environment?: string;
+    enabled: boolean;
+}
+export interface FeatureFlagGuardOptions {
+    /** HTTP status code when flag is OFF. Default: 403 */
+    statusCode?: number;
+    /** Response body when flag is OFF */
+    fallback?: Record<string, unknown>;
+}
+export interface FeatureFlagWithOverrides {
+    id: string;
+    key: string;
+    description: string | null;
+    enabled: boolean;
+    percentage: number;
+    metadata: Record<string, unknown>;
+    archivedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+    overrides: FlagOverride[];
+}
+export interface FlagOverride {
+    id: string;
+    flagId: string;
+    tenantId: string | null;
+    userId: string | null;
+    environment: string | null;
+    enabled: boolean;
+}

package/dist/interfaces/feature-flag.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=feature-flag.interface.js.map

package/dist/interfaces/feature-flag.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.interface.js","sourceRoot":"","sources":["../../src/interfaces/feature-flag.interface.ts"],"names":[],"mappings":""}

package/dist/middleware/flag-context.middleware.d.ts

@@ -0,0 +1,10 @@
+import { NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+import { FlagContext } from '../services/flag-context';
+import { FeatureFlagModuleOptions } from '../interfaces/feature-flag-options.interface';
+export declare class FlagContextMiddleware implements NestMiddleware {
+    private readonly context;
+    private readonly options;
+    constructor(context: FlagContext, options: FeatureFlagModuleOptions);
+    use(req: Request, _res: Response, next: NextFunction): void;
+}

package/dist/middleware/flag-context.middleware.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagContextMiddleware = void 0;
+const common_1 = require("@nestjs/common");
+const flag_context_1 = require("../services/flag-context");
+const feature_flag_constants_1 = require("../feature-flag.constants");
+let FlagContextMiddleware = class FlagContextMiddleware {
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+    }
+    use(req, _res, next) {
+        const userId = this.options.userIdExtractor?.(req) ?? null;
+        this.context.run({ userId }, () => next());
+    }
+};
+exports.FlagContextMiddleware = FlagContextMiddleware;
+exports.FlagContextMiddleware = FlagContextMiddleware = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [flag_context_1.FlagContext, Object])
+], FlagContextMiddleware);
+//# sourceMappingURL=flag-context.middleware.js.map

package/dist/middleware/flag-context.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag-context.middleware.js","sourceRoot":"","sources":["../../src/middleware/flag-context.middleware.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAAoE;AAEpE,2DAAuD;AACvD,sEAAwE;AAIjE,IAAM,qBAAqB,GAA3B,MAAM,qBAAqB;IAChC,YACmB,OAAoB,EACiB,OAAiC;QADtE,YAAO,GAAP,OAAO,CAAa;QACiB,YAAO,GAAP,OAAO,CAA0B;IACtF,CAAC;IAEJ,GAAG,CAAC,GAAY,EAAE,IAAc,EAAE,IAAkB;QAClD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;QAC3D,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7C,CAAC;CACF,CAAA;AAVY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,mBAAU,GAAE;IAIR,WAAA,IAAA,eAAM,EAAC,oDAA2B,CAAC,CAAA;qCADV,0BAAW;GAF5B,qBAAqB,CAUjC"}

package/dist/services/feature-flag.service.d.ts

@@ -0,0 +1,29 @@
+import { ModuleRef } from '@nestjs/core';
+import { FeatureFlagModuleOptions } from '../interfaces/feature-flag-options.interface';
+import { CreateFeatureFlagInput, UpdateFeatureFlagInput, SetOverrideInput, FeatureFlagWithOverrides } from '../interfaces/feature-flag.interface';
+import { EvaluationContext } from '../interfaces/evaluation-context.interface';
+import { FlagCacheService } from './flag-cache.service';
+import { FlagEvaluatorService } from './flag-evaluator.service';
+import { FlagContext } from './flag-context';
+export declare class FeatureFlagService {
+    private readonly options;
+    private readonly prisma;
+    private readonly cache;
+    private readonly evaluator;
+    private readonly flagContext;
+    private readonly moduleRef;
+    private readonly eventEmitter?;
+    constructor(options: FeatureFlagModuleOptions, prisma: any, cache: FlagCacheService, evaluator: FlagEvaluatorService, flagContext: FlagContext, moduleRef: ModuleRef, eventEmitter?: any | undefined);
+    isEnabled(flagKey: string, explicitContext?: EvaluationContext): Promise<boolean>;
+    evaluateAll(explicitContext?: EvaluationContext): Promise<Record<string, boolean>>;
+    create(input: CreateFeatureFlagInput): Promise<FeatureFlagWithOverrides>;
+    update(key: string, input: UpdateFeatureFlagInput): Promise<FeatureFlagWithOverrides>;
+    archive(key: string): Promise<FeatureFlagWithOverrides>;
+    setOverride(key: string, input: SetOverrideInput): Promise<void>;
+    findAll(): Promise<FeatureFlagWithOverrides[]>;
+    invalidateCache(): void;
+    private resolveFlag;
+    private resolveAllFlags;
+    private buildContext;
+    private getTenantId;
+}

package/dist/services/feature-flag.service.js

@@ -0,0 +1,208 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const feature_flag_constants_1 = require("../feature-flag.constants");
+const flag_cache_service_1 = require("./flag-cache.service");
+const flag_evaluator_service_1 = require("./flag-evaluator.service");
+const flag_context_1 = require("./flag-context");
+const feature_flag_events_1 = require("../events/feature-flag.events");
+let FeatureFlagService = class FeatureFlagService {
+    constructor(options, prisma, cache, evaluator, flagContext, moduleRef, eventEmitter) {
+        this.options = options;
+        this.prisma = prisma;
+        this.cache = cache;
+        this.evaluator = evaluator;
+        this.flagContext = flagContext;
+        this.moduleRef = moduleRef;
+        this.eventEmitter = eventEmitter;
+    }
+    async isEnabled(flagKey, explicitContext) {
+        const flag = await this.resolveFlag(flagKey);
+        if (!flag) {
+            return this.options.defaultOnMissing ?? false;
+        }
+        const context = this.buildContext(explicitContext);
+        const startTime = Date.now();
+        const { result, source } = this.evaluator.evaluate(flag, context);
+        const evaluationTimeMs = Date.now() - startTime;
+        if (this.options.emitEvents && this.eventEmitter) {
+            const event = {
+                flagKey,
+                result,
+                context,
+                source,
+                evaluationTimeMs,
+            };
+            this.eventEmitter.emit(feature_flag_events_1.FeatureFlagEvents.EVALUATED, event);
+        }
+        return result;
+    }
+    async evaluateAll(explicitContext) {
+        const flags = await this.resolveAllFlags();
+        const context = this.buildContext(explicitContext);
+        const result = {};
+        for (const flag of flags) {
+            result[flag.key] = this.evaluator.evaluate(flag, context).result;
+        }
+        return result;
+    }
+    async create(input) {
+        const flag = await this.prisma.featureFlag.create({
+            data: {
+                key: input.key,
+                description: input.description,
+                enabled: input.enabled ?? false,
+                percentage: input.percentage ?? 0,
+                metadata: input.metadata ?? {},
+            },
+            include: { overrides: true },
+        });
+        this.cache.invalidate();
+        if (this.options.emitEvents && this.eventEmitter) {
+            this.eventEmitter.emit(feature_flag_events_1.FeatureFlagEvents.CREATED, { flagKey: input.key, action: 'created' });
+        }
+        return flag;
+    }
+    async update(key, input) {
+        const flag = await this.prisma.featureFlag.update({
+            where: { key },
+            data: {
+                ...(input.description !== undefined && { description: input.description }),
+                ...(input.enabled !== undefined && { enabled: input.enabled }),
+                ...(input.percentage !== undefined && { percentage: input.percentage }),
+                ...(input.metadata !== undefined && { metadata: input.metadata }),
+            },
+            include: { overrides: true },
+        });
+        this.cache.invalidate(key);
+        if (this.options.emitEvents && this.eventEmitter) {
+            this.eventEmitter.emit(feature_flag_events_1.FeatureFlagEvents.UPDATED, { flagKey: key, action: 'updated' });
+        }
+        return flag;
+    }
+    async archive(key) {
+        const flag = await this.prisma.featureFlag.update({
+            where: { key },
+            data: { archivedAt: new Date() },
+            include: { overrides: true },
+        });
+        this.cache.invalidate(key);
+        if (this.options.emitEvents && this.eventEmitter) {
+            this.eventEmitter.emit(feature_flag_events_1.FeatureFlagEvents.ARCHIVED, { flagKey: key, action: 'archived' });
+        }
+        return flag;
+    }
+    async setOverride(key, input) {
+        const flag = await this.prisma.featureFlag.findUnique({ where: { key } });
+        if (!flag) {
+            throw new Error(`Feature flag "${key}" not found`);
+        }
+        const where = {
+            flagId: flag.id,
+            tenantId: input.tenantId ?? null,
+            userId: input.userId ?? null,
+            environment: input.environment ?? null,
+        };
+        const existing = await this.prisma.featureFlagOverride.findFirst({ where });
+        if (existing) {
+            await this.prisma.featureFlagOverride.update({
+                where: { id: existing.id },
+                data: { enabled: input.enabled },
+            });
+        }
+        else {
+            await this.prisma.featureFlagOverride.create({
+                data: { ...where, enabled: input.enabled },
+            });
+        }
+        this.cache.invalidate(key);
+        if (this.options.emitEvents && this.eventEmitter) {
+            this.eventEmitter.emit(feature_flag_events_1.FeatureFlagEvents.OVERRIDE_SET, {
+                flagKey: key,
+                ...input,
+                action: 'set',
+            });
+        }
+    }
+    async findAll() {
+        return this.prisma.featureFlag.findMany({
+            where: { archivedAt: null },
+            include: { overrides: true },
+            orderBy: { createdAt: 'desc' },
+        });
+    }
+    invalidateCache() {
+        this.cache.invalidate();
+        if (this.options.emitEvents && this.eventEmitter) {
+            this.eventEmitter.emit(feature_flag_events_1.FeatureFlagEvents.CACHE_INVALIDATED, {});
+        }
+    }
+    async resolveFlag(key) {
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const flag = await this.prisma.featureFlag.findUnique({
+            where: { key },
+            include: { overrides: true },
+        });
+        if (flag) {
+            this.cache.set(key, flag);
+        }
+        return flag;
+    }
+    async resolveAllFlags() {
+        const cached = this.cache.getAll();
+        if (cached)
+            return cached;
+        const flags = await this.prisma.featureFlag.findMany({
+            where: { archivedAt: null },
+            include: { overrides: true },
+        });
+        this.cache.setAll(flags);
+        return flags;
+    }
+    buildContext(explicit) {
+        return {
+            userId: explicit?.userId !== undefined ? explicit.userId : this.flagContext.getUserId(),
+            tenantId: explicit?.tenantId !== undefined ? explicit.tenantId : this.getTenantId(),
+            environment: explicit?.environment !== undefined ? explicit.environment : this.options.environment,
+        };
+    }
+    getTenantId() {
+        try {
+            const { TenancyService } = require('@nestarc/tenancy');
+            const tenancyService = this.moduleRef.get(TenancyService, { strict: false });
+            return tenancyService?.getCurrentTenant() ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+};
+exports.FeatureFlagService = FeatureFlagService;
+exports.FeatureFlagService = FeatureFlagService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(feature_flag_constants_1.FEATURE_FLAG_MODULE_OPTIONS)),
+    __param(1, (0, common_1.Inject)('PRISMA_SERVICE')),
+    __param(6, (0, common_1.Optional)()),
+    __param(6, (0, common_1.Inject)('EVENT_EMITTER')),
+    __metadata("design:paramtypes", [Object, Object, flag_cache_service_1.FlagCacheService,
+        flag_evaluator_service_1.FlagEvaluatorService,
+        flag_context_1.FlagContext,
+        core_1.ModuleRef, Object])
+], FeatureFlagService);
+//# sourceMappingURL=feature-flag.service.js.map