@mergedapp/feature-flags 0.1.3

package/dist/nestjs/constants.js

@@ -0,0 +1,4 @@
+export const FEATURE_FLAGS_MODULE_OPTIONS = Symbol("FEATURE_FLAGS_MODULE_OPTIONS");
+export const FEATURE_FLAGS_EVALUATOR = Symbol("FEATURE_FLAGS_EVALUATOR");
+export const FEATURE_FLAGS_REQUEST_CONTEXT = Symbol("FEATURE_FLAGS_REQUEST_CONTEXT");
+export const REQUIRE_FEATURE_FLAG_KEY = "REQUIRE_FEATURE_FLAG";

package/dist/nestjs/context.d.ts

@@ -0,0 +1,12 @@
+import { type ExecutionContext } from "@nestjs/common";
+import type { FeatureFlagEvaluationContext } from "@repo/types-v2";
+import type { FeatureFlagContextFactory } from "./types.js";
+export declare class FeatureFlagsRequestContextStore {
+    private readonly storage;
+    getContext(): FeatureFlagEvaluationContext | null;
+    run<T>(context: FeatureFlagEvaluationContext | null | undefined, callback: () => T): T;
+}
+export declare function resolveFeatureFlagContext(params: {
+    context: ExecutionContext;
+    contextFactory?: FeatureFlagContextFactory;
+}): Promise<FeatureFlagEvaluationContext | undefined>;

package/dist/nestjs/context.js

@@ -0,0 +1,24 @@
+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;
+};
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Injectable } from "@nestjs/common";
+let FeatureFlagsRequestContextStore = class FeatureFlagsRequestContextStore {
+    storage = new AsyncLocalStorage();
+    getContext() {
+        return this.storage.getStore() ?? null;
+    }
+    run(context, callback) {
+        return this.storage.run(context ?? null, callback);
+    }
+};
+FeatureFlagsRequestContextStore = __decorate([
+    Injectable()
+], FeatureFlagsRequestContextStore);
+export { FeatureFlagsRequestContextStore };
+export async function resolveFeatureFlagContext(params) {
+    return params.contextFactory ? params.contextFactory(params.context) : undefined;
+}

package/dist/nestjs/decorators.d.ts

@@ -0,0 +1,4 @@
+import type { RawFeatureFlagGateOptions, RawRequireFeatureFlagOptions } from "./types.js";
+export declare function RequireFeatureFlag(options: RawRequireFeatureFlagOptions): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export declare function FeatureFlagGate(options: RawFeatureFlagGateOptions): MethodDecorator;
+export declare const FeatureFlagContext: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/dist/nestjs/decorators.js

@@ -0,0 +1,45 @@
+import { SetMetadata, UseGuards, applyDecorators, createParamDecorator } from "@nestjs/common";
+import { FEATURE_FLAGS_REQUEST_CONTEXT, REQUIRE_FEATURE_FLAG_KEY } from "./constants.js";
+import { FeatureFlagGateError } from "./errors.js";
+import { FeatureFlagGuard, evaluateGate } from "./guard.js";
+export function RequireFeatureFlag(options) {
+    return applyDecorators(SetMetadata(REQUIRE_FEATURE_FLAG_KEY, options), UseGuards(FeatureFlagGuard));
+}
+export function FeatureFlagGate(options) {
+    return (_target, _propertyKey, descriptor) => {
+        const original = descriptor.value;
+        if (typeof original !== "function") {
+            return descriptor;
+        }
+        descriptor.value = async function wrappedFeatureFlagGate(...args) {
+            const serviceProperty = options.serviceProperty ?? "featureFlags";
+            const featureFlagsService = this[serviceProperty];
+            if (!isFeatureFlagsService(featureFlagsService)) {
+                throw new TypeError(`FeatureFlagGate expected a FeatureFlagsService instance on this.${serviceProperty}.`);
+            }
+            const context = options.resolveContext ? await options.resolveContext(this, args) : options.context;
+            const allowed = await evaluateGate({
+                context,
+                defaultValue: options.defaultValue ?? false,
+                expectedValue: options.expectedValue,
+                featureFlagsService,
+                flagKey: options.flagKey,
+            });
+            if (!allowed) {
+                throw new FeatureFlagGateError({ flagKey: options.flagKey });
+            }
+            return original.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+export const FeatureFlagContext = createParamDecorator((_data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request?.[FEATURE_FLAGS_REQUEST_CONTEXT] ?? null;
+});
+function isFeatureFlagsService(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "getDetails" in value &&
+        typeof value.getDetails === "function");
+}

package/dist/nestjs/errors.d.ts

@@ -0,0 +1,12 @@
+import { HttpException } from "@nestjs/common";
+export declare class FeatureFlagDisabledHttpException extends HttpException {
+    constructor({ flagKey, message }: {
+        flagKey: string;
+        message?: string;
+    });
+}
+export declare class FeatureFlagGateError extends FeatureFlagDisabledHttpException {
+    constructor({ flagKey }: {
+        flagKey: string;
+    });
+}

package/dist/nestjs/errors.js

@@ -0,0 +1,20 @@
+import { HttpException, HttpStatus } from "@nestjs/common";
+export class FeatureFlagDisabledHttpException extends HttpException {
+    constructor({ flagKey, message }) {
+        super({
+            code: "FEATURE_FLAG_DISABLED",
+            error: "FEATURE_FLAG_DISABLED",
+            message: message ?? `Feature flag (${flagKey}) is disabled for this request.`,
+            statusCode: HttpStatus.FORBIDDEN,
+        }, HttpStatus.FORBIDDEN);
+    }
+}
+export class FeatureFlagGateError extends FeatureFlagDisabledHttpException {
+    constructor({ flagKey }) {
+        super({
+            flagKey,
+            message: `Feature flag (${flagKey}) blocked this service method.`,
+        });
+        this.name = "FeatureFlagGateError";
+    }
+}

package/dist/nestjs/evaluator.d.ts

@@ -0,0 +1,17 @@
+import type { FeatureFlagEvaluationContext } from "@repo/types-v2";
+import type { FlagRegistry } from "../types.js";
+import type { FeatureFlagEvaluationDetails, NativeFeatureFlagsModuleOptions } from "./types.js";
+export type FeatureFlagsEvaluationRequest<TValue> = {
+    context?: FeatureFlagEvaluationContext;
+    defaultValue: TValue;
+    flagKey: string;
+};
+export interface NestFeatureFlagsEvaluator {
+    getDetails<TValue>(request: FeatureFlagsEvaluationRequest<TValue>): Promise<FeatureFlagEvaluationDetails<TValue>>;
+}
+export declare class NativeNestFeatureFlagsEvaluator<TFlags extends FlagRegistry = Record<string, unknown>> implements NestFeatureFlagsEvaluator {
+    private readonly options;
+    private readonly evaluator;
+    constructor(options: NativeFeatureFlagsModuleOptions<TFlags>);
+    getDetails<TValue>(request: FeatureFlagsEvaluationRequest<TValue>): Promise<FeatureFlagEvaluationDetails<TValue>>;
+}

package/dist/nestjs/evaluator.js

@@ -0,0 +1,83 @@
+import { RemoteFeatureFlagEvaluator } from "../remote-evaluator.js";
+export class NativeNestFeatureFlagsEvaluator {
+    options;
+    evaluator;
+    constructor(options) {
+        this.options = options;
+        this.evaluator = new RemoteFeatureFlagEvaluator(options);
+    }
+    async getDetails(request) {
+        const evaluation = await this.evaluator.evaluate(request.context ?? null);
+        const flag = findEvaluatedFlag({
+            flags: evaluation.flags,
+            flagIds: this.options.flagIds,
+            flagKey: request.flagKey,
+        });
+        if (!flag) {
+            return {
+                errorCode: "FLAG_NOT_FOUND",
+                errorMessage: `Feature flag (${request.flagKey}) was not found.`,
+                flagKey: request.flagKey,
+                flagMetadata: {},
+                reason: "ERROR",
+                value: request.defaultValue,
+            };
+        }
+        if (!matchesExpectedType({
+            defaultValue: request.defaultValue,
+            flag,
+        })) {
+            return {
+                errorCode: "TYPE_MISMATCH",
+                errorMessage: `Feature flag (${flag.name}) resolved as ${flag.type}, which does not match the requested default value type.`,
+                flagKey: request.flagKey,
+                flagMetadata: createEvaluationMetadata(flag),
+                reason: "ERROR",
+                value: request.defaultValue,
+            };
+        }
+        return {
+            flagKey: request.flagKey,
+            flagMetadata: createEvaluationMetadata(flag),
+            reason: flag.enabled ? "TARGETING_MATCH" : "DISABLED",
+            value: flag.value,
+        };
+    }
+}
+function createEvaluationMetadata(flag) {
+    return {
+        enabled: flag.enabled,
+        id: flag.id,
+        name: flag.name,
+        teamId: flag.teamId ?? undefined,
+        type: flag.type,
+    };
+}
+function findEvaluatedFlag(params) {
+    const resolvedId = params.flagIds?.[params.flagKey];
+    if (resolvedId) {
+        const matchedByResolvedId = params.flags.find((flag) => flag.id === resolvedId);
+        if (matchedByResolvedId) {
+            return matchedByResolvedId;
+        }
+    }
+    return (params.flags.find((flag) => flag.id === params.flagKey) ?? params.flags.find((flag) => flag.name === params.flagKey));
+}
+function matchesExpectedType(params) {
+    if (typeof params.defaultValue === "boolean") {
+        return params.flag.type === "BOOLEAN";
+    }
+    if (typeof params.defaultValue === "string") {
+        return params.flag.type === "STRING";
+    }
+    if (typeof params.defaultValue === "number") {
+        return params.flag.type === "NUMBER";
+    }
+    if (Array.isArray(params.defaultValue)) {
+        return params.flag.type === "ARRAY";
+    }
+    return params.flag.type === "JSON" && isObjectLikeValue(params.defaultValue);
+}
+function isObjectLikeValue(value) {
+    return value === null || typeof value === "object";
+}

package/dist/nestjs/guard.d.ts

@@ -0,0 +1,19 @@
+import { CanActivate, ExecutionContext } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import type { FeatureFlagEvaluationContext } from "@repo/types-v2";
+import { FeatureFlagsService } from "./service.js";
+import type { RawRequireFeatureFlagOptions } from "./types.js";
+export type RequireFeatureFlagMetadata = RawRequireFeatureFlagOptions;
+export declare class FeatureFlagGuard implements CanActivate {
+    private readonly reflector;
+    private readonly featureFlagsService;
+    constructor(reflector: Reflector, featureFlagsService: FeatureFlagsService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}
+export declare function evaluateGate(params: {
+    context?: FeatureFlagEvaluationContext;
+    defaultValue: boolean | number | string;
+    expectedValue?: boolean | number | string;
+    featureFlagsService: FeatureFlagsService;
+    flagKey: string;
+}): Promise<boolean>;

package/dist/nestjs/guard.js

@@ -0,0 +1,63 @@
+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);
+};
+import { Injectable } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { REQUIRE_FEATURE_FLAG_KEY } from "./constants.js";
+import { resolveFeatureFlagContext } from "./context.js";
+import { FeatureFlagDisabledHttpException } from "./errors.js";
+import { FeatureFlagsService } from "./service.js";
+let FeatureFlagGuard = class FeatureFlagGuard {
+    reflector;
+    featureFlagsService;
+    constructor(reflector, featureFlagsService) {
+        this.reflector = reflector;
+        this.featureFlagsService = featureFlagsService;
+    }
+    async canActivate(context) {
+        const metadata = this.reflector.getAllAndOverride(REQUIRE_FEATURE_FLAG_KEY, [context.getHandler(), context.getClass()]);
+        if (!metadata) {
+            return true;
+        }
+        const evaluationContext = metadata.contextFactory
+            ? await resolveFeatureFlagContext({
+                context,
+                contextFactory: metadata.contextFactory,
+            })
+            : metadata.context;
+        const allowed = await evaluateGate({
+            context: evaluationContext,
+            defaultValue: metadata.defaultValue ?? false,
+            expectedValue: metadata.expectedValue,
+            featureFlagsService: this.featureFlagsService,
+            flagKey: metadata.flagKey,
+        });
+        if (!allowed) {
+            throw new FeatureFlagDisabledHttpException({ flagKey: metadata.flagKey });
+        }
+        return true;
+    }
+};
+FeatureFlagGuard = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [Reflector,
+        FeatureFlagsService])
+], FeatureFlagGuard);
+export { FeatureFlagGuard };
+export async function evaluateGate(params) {
+    const details = await params.featureFlagsService.getDetails({
+        context: params.context,
+        defaultValue: params.defaultValue,
+        flagKey: params.flagKey,
+    });
+    if (typeof params.expectedValue === "undefined") {
+        return Boolean(details.value);
+    }
+    return Object.is(details.value, params.expectedValue);
+}

package/dist/nestjs/interceptor.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from "rxjs";
+import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
+import { FeatureFlagsRequestContextStore } from "./context.js";
+import type { NativeFeatureFlagsModuleOptions } from "./types.js";
+export declare class FeatureFlagContextInterceptor implements NestInterceptor {
+    private readonly options;
+    private readonly requestContextStore;
+    constructor(options: NativeFeatureFlagsModuleOptions, requestContextStore: FeatureFlagsRequestContextStore);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<unknown>>;
+}

package/dist/nestjs/interceptor.js

@@ -0,0 +1,53 @@
+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); }
+};
+import { Observable } from "rxjs";
+import { Inject, Injectable } from "@nestjs/common";
+import { FEATURE_FLAGS_MODULE_OPTIONS, FEATURE_FLAGS_REQUEST_CONTEXT } from "./constants.js";
+import { FeatureFlagsRequestContextStore, resolveFeatureFlagContext } from "./context.js";
+let FeatureFlagContextInterceptor = class FeatureFlagContextInterceptor {
+    options;
+    requestContextStore;
+    constructor(options, requestContextStore) {
+        this.options = options;
+        this.requestContextStore = requestContextStore;
+    }
+    async intercept(context, next) {
+        const evaluationContext = await resolveFeatureFlagContext({
+            context,
+            contextFactory: this.options.contextFactory,
+        });
+        const request = context.switchToHttp().getRequest();
+        if (request) {
+            request[FEATURE_FLAGS_REQUEST_CONTEXT] = evaluationContext ?? null;
+        }
+        return new Observable((subscriber) => {
+            let innerSubscription;
+            this.requestContextStore.run(evaluationContext ?? null, () => {
+                innerSubscription = next.handle().subscribe({
+                    complete: () => subscriber.complete(),
+                    error: (error) => subscriber.error(error),
+                    next: (value) => subscriber.next(value),
+                });
+            });
+            return () => {
+                innerSubscription?.unsubscribe();
+            };
+        });
+    }
+};
+FeatureFlagContextInterceptor = __decorate([
+    Injectable(),
+    __param(0, Inject(FEATURE_FLAGS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, FeatureFlagsRequestContextStore])
+], FeatureFlagContextInterceptor);
+export { FeatureFlagContextInterceptor };

package/dist/nestjs/module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from "@nestjs/common";
+import type { NativeFeatureFlagsModuleAsyncOptions, NativeFeatureFlagsModuleOptions } from "./types.js";
+export declare class FeatureFlagsModule {
+    static forRoot<TFlags extends Record<string, unknown> = Record<string, unknown>>(options: NativeFeatureFlagsModuleOptions<TFlags>): DynamicModule;
+    static forRootAsync<TFlags extends Record<string, unknown> = Record<string, unknown>>(options: NativeFeatureFlagsModuleAsyncOptions<TFlags>): DynamicModule;
+}

package/dist/nestjs/module.js

@@ -0,0 +1,67 @@
+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;
+};
+import { Module } from "@nestjs/common";
+import { APP_INTERCEPTOR } from "@nestjs/core";
+import { FEATURE_FLAGS_EVALUATOR, FEATURE_FLAGS_MODULE_OPTIONS } from "./constants.js";
+import { FeatureFlagsRequestContextStore } from "./context.js";
+import { NativeNestFeatureFlagsEvaluator } from "./evaluator.js";
+import { FeatureFlagGuard } from "./guard.js";
+import { FeatureFlagContextInterceptor } from "./interceptor.js";
+import { FeatureFlagsService } from "./service.js";
+let FeatureFlagsModule = class FeatureFlagsModule {
+    static forRoot(options) {
+        return createFeatureFlagsModule({
+            provideOptions: {
+                provide: FEATURE_FLAGS_MODULE_OPTIONS,
+                useValue: options,
+            },
+        });
+    }
+    static forRootAsync(options) {
+        return createFeatureFlagsModule({
+            imports: options.imports ?? [],
+            provideOptions: {
+                provide: FEATURE_FLAGS_MODULE_OPTIONS,
+                inject: options.inject ?? [],
+                useFactory: options.useFactory,
+            },
+        });
+    }
+};
+FeatureFlagsModule = __decorate([
+    Module({})
+], FeatureFlagsModule);
+export { FeatureFlagsModule };
+function createFeatureFlagsModule(params) {
+    return {
+        module: FeatureFlagsModule,
+        imports: params.imports ?? [],
+        providers: [
+            params.provideOptions,
+            FeatureFlagsRequestContextStore,
+            FeatureFlagsService,
+            FeatureFlagGuard,
+            FeatureFlagContextInterceptor,
+            {
+                provide: FEATURE_FLAGS_EVALUATOR,
+                inject: [FEATURE_FLAGS_MODULE_OPTIONS],
+                useFactory: (options) => new NativeNestFeatureFlagsEvaluator(options),
+            },
+            {
+                provide: APP_INTERCEPTOR,
+                inject: [FEATURE_FLAGS_MODULE_OPTIONS, FeatureFlagContextInterceptor],
+                useFactory: (options, interceptor) => options.useGlobalInterceptor === false ? new PassthroughInterceptor() : interceptor,
+            },
+        ],
+        exports: [FeatureFlagsRequestContextStore, FeatureFlagsService, FeatureFlagGuard, FeatureFlagContextInterceptor],
+    };
+}
+class PassthroughInterceptor {
+    intercept(_context, next) {
+        return next.handle();
+    }
+}

package/dist/nestjs/service.d.ts

@@ -0,0 +1,30 @@
+import type { FlagRegistry } from "../types.js";
+import { FeatureFlagsRequestContextStore } from "./context.js";
+import type { BooleanFlagKey, FeatureFlagEvaluationDetails, FlagKey } from "./types.js";
+import type { NestFeatureFlagsEvaluator } from "./evaluator.js";
+import type { FeatureFlagEvaluationContext } from "@repo/types-v2";
+export declare class FeatureFlagsService<TFlags extends FlagRegistry = Record<string, unknown>> {
+    private readonly evaluator;
+    private readonly requestContextStore;
+    constructor(evaluator: NestFeatureFlagsEvaluator, requestContextStore: FeatureFlagsRequestContextStore);
+    getDetails<K extends FlagKey<TFlags>>(params: {
+        context?: FeatureFlagEvaluationContext;
+        defaultValue: TFlags[K];
+        flagKey: K;
+    }): Promise<FeatureFlagEvaluationDetails<TFlags[K]>>;
+    getValue<K extends FlagKey<TFlags>>(params: {
+        context?: FeatureFlagEvaluationContext;
+        defaultValue: TFlags[K];
+        flagKey: K;
+    }): Promise<TFlags[K]>;
+    getBooleanDetails<K extends BooleanFlagKey<TFlags>>(params: {
+        context?: FeatureFlagEvaluationContext;
+        defaultValue?: boolean;
+        flagKey: K;
+    }): Promise<FeatureFlagEvaluationDetails<boolean>>;
+    isEnabled<K extends BooleanFlagKey<TFlags>>(params: {
+        context?: FeatureFlagEvaluationContext;
+        defaultValue?: boolean;
+        flagKey: K;
+    }): Promise<boolean>;
+}

package/dist/nestjs/service.js

@@ -0,0 +1,51 @@
+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); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { FEATURE_FLAGS_EVALUATOR } from "./constants.js";
+import { FeatureFlagsRequestContextStore } from "./context.js";
+let FeatureFlagsService = class FeatureFlagsService {
+    evaluator;
+    requestContextStore;
+    constructor(evaluator, requestContextStore) {
+        this.evaluator = evaluator;
+        this.requestContextStore = requestContextStore;
+    }
+    getDetails(params) {
+        return this.evaluator.getDetails({
+            context: params.context ?? this.requestContextStore.getContext() ?? undefined,
+            defaultValue: params.defaultValue,
+            flagKey: params.flagKey,
+        });
+    }
+    async getValue(params) {
+        const details = await this.getDetails(params);
+        return details.value;
+    }
+    getBooleanDetails(params) {
+        return this.getDetails({
+            context: params.context,
+            defaultValue: (params.defaultValue ?? false),
+            flagKey: params.flagKey,
+        });
+    }
+    async isEnabled(params) {
+        const details = await this.getBooleanDetails(params);
+        return details.value;
+    }
+};
+FeatureFlagsService = __decorate([
+    Injectable(),
+    __param(0, Inject(FEATURE_FLAGS_EVALUATOR)),
+    __metadata("design:paramtypes", [Object, FeatureFlagsRequestContextStore])
+], FeatureFlagsService);
+export { FeatureFlagsService };

package/dist/nestjs/types.d.ts

@@ -0,0 +1,100 @@
+import type { DynamicModule, ExecutionContext } from "@nestjs/common";
+import type { EvaluatedFlag, FeatureFlagEvaluationContext } from "@repo/types-v2";
+import type { FeatureFlagClientConfig, FlagRegistry } from "../types.js";
+type AnyFlagRegistry = Record<string, unknown>;
+export type FlagKey<TFlags extends FlagRegistry> = Extract<keyof TFlags, string>;
+type KeysMatching<TFlags extends FlagRegistry, TValue> = Extract<{
+    [K in keyof TFlags]-?: TFlags[K] extends TValue ? K : never;
+}[keyof TFlags], string>;
+export type BooleanFlagKey<TFlags extends FlagRegistry> = KeysMatching<TFlags, boolean>;
+export type StringFlagKey<TFlags extends FlagRegistry> = KeysMatching<TFlags, string>;
+export type NumberFlagKey<TFlags extends FlagRegistry> = KeysMatching<TFlags, number>;
+export type ScalarFlagKey<TFlags extends FlagRegistry> = BooleanFlagKey<TFlags> | StringFlagKey<TFlags> | NumberFlagKey<TFlags>;
+export type ComparableFlagKey<TFlags extends FlagRegistry> = ScalarFlagKey<TFlags>;
+export type NonBooleanComparableFlagKey<TFlags extends FlagRegistry> = Exclude<ComparableFlagKey<TFlags>, BooleanFlagKey<TFlags>>;
+export type ObjectFlagKey<TFlags extends FlagRegistry> = Exclude<FlagKey<TFlags>, ComparableFlagKey<TFlags>>;
+export type FeatureFlagContextFactory = (context: ExecutionContext) => Promise<FeatureFlagEvaluationContext | undefined> | FeatureFlagEvaluationContext | undefined;
+export type FeatureFlagEvaluationReason = "DISABLED" | "ERROR" | "TARGETING_MATCH";
+export type FeatureFlagEvaluationMetadata = {
+    enabled?: boolean;
+    id?: string;
+    name?: string;
+    teamId?: string;
+    type?: EvaluatedFlag["type"];
+};
+export type FeatureFlagEvaluationDetails<TValue> = {
+    errorCode?: "FLAG_NOT_FOUND" | "TYPE_MISMATCH";
+    errorMessage?: string;
+    flagKey: string;
+    flagMetadata: FeatureFlagEvaluationMetadata;
+    reason: FeatureFlagEvaluationReason;
+    value: TValue;
+};
+export type NativeFeatureFlagsModuleOptions<TFlags extends FlagRegistry = AnyFlagRegistry> = Pick<FeatureFlagClientConfig<TFlags>, "apiUrl" | "clientKey" | "environmentId" | "flagIds" | "organizationId" | "publicKey" | "teamId"> & {
+    contextFactory?: FeatureFlagContextFactory;
+    useGlobalInterceptor?: boolean;
+};
+export type NativeFeatureFlagsModuleAsyncOptions<TFlags extends FlagRegistry = AnyFlagRegistry> = {
+    imports?: DynamicModule["imports"];
+    inject?: Array<string | symbol | Function>;
+    useFactory: (...args: unknown[]) => Promise<NativeFeatureFlagsModuleOptions<TFlags>> | NativeFeatureFlagsModuleOptions<TFlags>;
+};
+export type RawRequireFeatureFlagOptions = {
+    context?: FeatureFlagEvaluationContext;
+    contextFactory?: FeatureFlagContextFactory;
+    defaultValue?: boolean | number | string;
+    expectedValue?: boolean | number | string;
+    flagKey: string;
+};
+export type RawFeatureFlagGateOptions = RawRequireFeatureFlagOptions & {
+    resolveContext?: (self: object, args: unknown[]) => Promise<FeatureFlagEvaluationContext | undefined> | FeatureFlagEvaluationContext | undefined;
+    serviceProperty?: string;
+};
+type TypedBooleanRequireFeatureFlagOptions<TFlags extends FlagRegistry> = {
+    context?: FeatureFlagEvaluationContext;
+    contextFactory?: FeatureFlagContextFactory;
+    defaultValue?: boolean;
+    flagKey: BooleanFlagKey<TFlags>;
+};
+type TypedMatchedRequireFeatureFlagOptions<TFlags extends FlagRegistry> = {
+    [K in NonBooleanComparableFlagKey<TFlags>]: {
+        context?: FeatureFlagEvaluationContext;
+        contextFactory?: FeatureFlagContextFactory;
+        defaultValue: TFlags[K];
+        expectedValue: TFlags[K];
+        flagKey: K;
+    };
+}[NonBooleanComparableFlagKey<TFlags>];
+export type TypedRequireFeatureFlagOptions<TFlags extends FlagRegistry> = TypedBooleanRequireFeatureFlagOptions<TFlags> | TypedMatchedRequireFeatureFlagOptions<TFlags>;
+type TypedBooleanFeatureFlagGateOptions<TFlags extends FlagRegistry> = {
+    defaultValue?: boolean;
+    flagKey: BooleanFlagKey<TFlags>;
+    resolveContext?: (self: object, args: unknown[]) => Promise<FeatureFlagEvaluationContext | undefined> | FeatureFlagEvaluationContext | undefined;
+    serviceProperty?: string;
+};
+type TypedMatchedFeatureFlagGateOptions<TFlags extends FlagRegistry> = {
+    [K in NonBooleanComparableFlagKey<TFlags>]: {
+        defaultValue: TFlags[K];
+        expectedValue: TFlags[K];
+        flagKey: K;
+        resolveContext?: (self: object, args: unknown[]) => Promise<FeatureFlagEvaluationContext | undefined> | FeatureFlagEvaluationContext | undefined;
+        serviceProperty?: string;
+    };
+}[NonBooleanComparableFlagKey<TFlags>];
+export type TypedFeatureFlagGateOptions<TFlags extends FlagRegistry> = TypedBooleanFeatureFlagGateOptions<TFlags> | TypedMatchedFeatureFlagGateOptions<TFlags>;
+export type TypedFeatureFlagsModuleOptions<TFlags extends FlagRegistry> = Omit<NativeFeatureFlagsModuleOptions<TFlags>, "flagIds">;
+export type TypedFeatureFlagsModuleAsyncOptions<TFlags extends FlagRegistry> = {
+    imports?: DynamicModule["imports"];
+    inject?: Array<string | symbol | Function>;
+    useFactory: (...args: unknown[]) => Promise<TypedFeatureFlagsModuleOptions<TFlags>> | TypedFeatureFlagsModuleOptions<TFlags>;
+};
+export type TypedFeatureFlagsModuleFacade<TFlags extends FlagRegistry> = {
+    forRoot(options: TypedFeatureFlagsModuleOptions<TFlags>): DynamicModule;
+    forRootAsync(options: TypedFeatureFlagsModuleAsyncOptions<TFlags>): DynamicModule;
+};
+export type TypedNestjsBindings<TFlags extends FlagRegistry> = {
+    FeatureFlagGate(options: TypedFeatureFlagGateOptions<TFlags>): MethodDecorator;
+    FeatureFlagsModule: TypedFeatureFlagsModuleFacade<TFlags>;
+    RequireFeatureFlag(options: TypedRequireFeatureFlagOptions<TFlags>): ClassDecorator & MethodDecorator;
+};
+export {};

package/dist/nestjs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/nestjs.cjs

@@ -0,0 +1 @@
+module.exports = require("./cjs/nestjs.js")