@mergedapp/feature-flags 0.1.3

package/dist/client.js

@@ -0,0 +1,501 @@
+import { FeatureFlagNetworkError, FeatureFlagVerificationError } from "./errors.js";
+import { buildSnapshotScopeParts, createDefaultFeatureFlagRuntimeStatus, createPersistedFeatureFlagSnapshot, doesSnapshotMatchScope, getSnapshotKeyPrefix, resolveSnapshotStore, serializeCanonicalValue, } from "./persistence.js";
+import { importPublicKey, resetPublicKeyCache, verifyFeatureFlagTokenDetailed } from "./jwt.js";
+const DEFAULT_REFRESH_INTERVAL_MS = 60_000;
+const BACKOFF_BASE_MS = 5_000;
+const BACKOFF_CAP_MS = 300_000;
+export class MergedFeatureFlags {
+    flagsById = new Map();
+    flagsByName = new Map();
+    publicKeyPem;
+    publicKeyCrypto = null;
+    refreshTimer = null;
+    backoffMs = 0;
+    consecutiveFailures = 0;
+    listeners = new Set();
+    storeListeners = new Set();
+    initialized = false;
+    visibilityHandler = null;
+    pendingScopeTransition = false;
+    runtimeStatus = createDefaultFeatureFlagRuntimeStatus();
+    snapshotStorePromise = null;
+    keyPrefix;
+    contextSignature;
+    flagIds;
+    clientKey;
+    apiUrl;
+    organizationId;
+    environmentId;
+    teamId;
+    refreshInterval;
+    onError;
+    onFlagsChanged;
+    snapshotPersistence;
+    evaluationContext;
+    constructor(config) {
+        this.flagIds = config.flagIds ?? null;
+        this.clientKey = config.clientKey;
+        this.apiUrl = config.apiUrl.replace(/\/$/, "");
+        this.organizationId = config.organizationId.trim();
+        this.environmentId = config.environmentId.trim();
+        this.teamId = config.teamId?.trim() || null;
+        this.publicKeyPem = config.publicKey ?? null;
+        this.refreshInterval = config.refreshInterval ?? DEFAULT_REFRESH_INTERVAL_MS;
+        this.onError = config.onError ?? null;
+        this.onFlagsChanged = config.onFlagsChanged ?? null;
+        this.snapshotPersistence = config.snapshotPersistence;
+        this.evaluationContext = config.evaluationContext ?? null;
+        this.contextSignature = serializeCanonicalValue(this.evaluationContext ?? null);
+        this.keyPrefix = getSnapshotKeyPrefix({ config });
+        if (!this.organizationId) {
+            throw new TypeError("organizationId is required.");
+        }
+        if (!this.environmentId) {
+            throw new TypeError("environmentId is required.");
+        }
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        try {
+            const restored = await this.restorePersistedSnapshot().catch(() => false);
+            try {
+                await this.refresh();
+            }
+            catch {
+                if (!restored) {
+                    this.clearFlags();
+                    this.setRuntimeStatus({
+                        source: "defaults",
+                        tokenExpiresAt: null,
+                    });
+                    this.emitChange({ flagsChanged: true, storeChanged: true });
+                }
+            }
+        }
+        finally {
+            if (this.refreshInterval > 0) {
+                this.startPolling();
+            }
+        }
+    }
+    isEnabled(name) {
+        return this.resolveFlag(name)?.enabled ?? false;
+    }
+    getValue(name) {
+        const flag = this.resolveFlag(name);
+        return flag?.value;
+    }
+    getFlag(name) {
+        return this.resolveFlag(name);
+    }
+    getAllFlags() {
+        return Array.from(this.flagsById.values());
+    }
+    getStatus() {
+        const tokenExpiresAt = this.runtimeStatus.tokenExpiresAt;
+        const isStale = tokenExpiresAt != null &&
+            Number.isFinite(new Date(tokenExpiresAt).getTime()) &&
+            new Date(tokenExpiresAt).getTime() <= Date.now();
+        return {
+            ...this.runtimeStatus,
+            isStale,
+        };
+    }
+    getStatusSnapshot() {
+        return this.getStatus();
+    }
+    async refresh() {
+        const restoredForCurrentScope = this.pendingScopeTransition
+            ? await this.restorePersistedSnapshot().catch(() => false)
+            : false;
+        try {
+            await this.ensureVerificationKey();
+            const response = await this.fetchSignedFlags();
+            const verifiedFlags = await this.verifyWithRetry(response.token);
+            const fetchedAt = new Date().toISOString();
+            const flagsChanged = this.updateFlags(verifiedFlags.flags);
+            this.resetBackoff();
+            this.pendingScopeTransition = false;
+            this.setRuntimeStatus({
+                source: "network",
+                tokenExpiresAt: verifiedFlags.expiresAt,
+                lastSuccessfulRefreshAt: fetchedAt,
+                lastError: null,
+            });
+            await this.persistSnapshot({
+                fetchedAt,
+                token: response.token,
+                tokenExpiresAt: verifiedFlags.expiresAt,
+            });
+            this.emitChange({ flagsChanged, storeChanged: true });
+        }
+        catch (error) {
+            this.incrementBackoff();
+            const wrappedError = error instanceof Error ? error : new FeatureFlagNetworkError("Unknown error during refresh.");
+            if (this.pendingScopeTransition && !restoredForCurrentScope) {
+                const hadFlags = this.flagsById.size > 0;
+                this.clearFlags();
+                this.pendingScopeTransition = false;
+                this.setRuntimeStatus({
+                    source: "defaults",
+                    tokenExpiresAt: null,
+                    lastSuccessfulRefreshAt: null,
+                    lastError: wrappedError,
+                });
+                this.emitChange({ flagsChanged: hadFlags, storeChanged: true });
+            }
+            else {
+                this.setRuntimeStatus({ lastError: wrappedError });
+                this.emitChange({ flagsChanged: false, storeChanged: true });
+            }
+            this.onError?.(wrappedError);
+            throw wrappedError;
+        }
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    getSnapshot() {
+        return this.getAllFlags();
+    }
+    setEvaluationContext(context) {
+        const nextContext = context ?? null;
+        const nextSignature = serializeCanonicalValue(nextContext ?? null);
+        if (nextSignature === this.contextSignature) {
+            this.evaluationContext = nextContext;
+            return;
+        }
+        this.evaluationContext = nextContext;
+        this.contextSignature = nextSignature;
+        this.pendingScopeTransition = true;
+    }
+    subscribe(onStoreChange) {
+        this.storeListeners.add(onStoreChange);
+        return () => {
+            this.storeListeners.delete(onStoreChange);
+        };
+    }
+    destroy() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        if (this.visibilityHandler && typeof document !== "undefined") {
+            document.removeEventListener("visibilitychange", this.visibilityHandler);
+            this.visibilityHandler = null;
+        }
+        this.listeners.clear();
+        this.storeListeners.clear();
+        this.clearFlags();
+        this.pendingScopeTransition = false;
+        this.runtimeStatus = createDefaultFeatureFlagRuntimeStatus();
+        this.initialized = false;
+    }
+    resolveFlag(name) {
+        if (this.flagIds && name in this.flagIds) {
+            const id = this.flagIds[name];
+            return this.flagsById.get(id);
+        }
+        return this.flagsById.get(name) ?? this.flagsByName.get(name);
+    }
+    clearFlags() {
+        this.flagsById.clear();
+        this.flagsByName.clear();
+    }
+    emitChange(params) {
+        const allFlags = this.getAllFlags();
+        if (params.flagsChanged) {
+            this.onFlagsChanged?.(allFlags);
+            for (const listener of this.listeners) {
+                listener(allFlags);
+            }
+        }
+        if (params.storeChanged) {
+            for (const listener of this.storeListeners) {
+                listener();
+            }
+        }
+    }
+    updateFlags(flags) {
+        const oldFlags = new Map(this.flagsById);
+        this.clearFlags();
+        for (const flag of flags) {
+            this.flagsById.set(flag.id, flag);
+            this.flagsByName.set(flag.name, flag);
+        }
+        return this.hasFlagsChanged(oldFlags, this.flagsById);
+    }
+    hasFlagsChanged(oldFlags, newFlags) {
+        if (oldFlags.size !== newFlags.size) {
+            return true;
+        }
+        for (const [id, newFlag] of newFlags) {
+            const oldFlag = oldFlags.get(id);
+            if (!oldFlag) {
+                return true;
+            }
+            if (oldFlag.enabled !== newFlag.enabled ||
+                oldFlag.name !== newFlag.name ||
+                JSON.stringify(oldFlag.value) !== JSON.stringify(newFlag.value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    setRuntimeStatus(patch) {
+        this.runtimeStatus = {
+            ...this.runtimeStatus,
+            ...patch,
+        };
+    }
+    async fetchSignedFlags() {
+        const url = new URL("/api/feature-flags/evaluate/signed", this.apiUrl);
+        const payload = {
+            organizationId: this.organizationId,
+            environmentId: this.environmentId,
+            ...(this.teamId ? { teamId: this.teamId } : {}),
+            ...(this.evaluationContext ? { context: this.evaluationContext } : {}),
+        };
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.clientKey}`,
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+                body: JSON.stringify(payload),
+            });
+        }
+        catch (error) {
+            throw new FeatureFlagNetworkError("Failed to fetch feature flags.", { cause: error });
+        }
+        if (!response.ok) {
+            throw new FeatureFlagNetworkError(`Feature flag API returned ${response.status}: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    async fetchPublicKey() {
+        const url = `${this.apiUrl}/api/feature-flags/public-key`;
+        let response;
+        try {
+            response = await fetch(url);
+        }
+        catch (error) {
+            throw new FeatureFlagNetworkError("Failed to fetch public key.", { cause: error });
+        }
+        if (!response.ok) {
+            throw new FeatureFlagNetworkError(`Public key endpoint returned ${response.status}: ${response.statusText}`);
+        }
+        const body = (await response.json());
+        return body.publicKey;
+    }
+    async verifyWithRetry(token) {
+        try {
+            return await verifyFeatureFlagTokenDetailed({ token, publicKey: this.publicKeyCrypto });
+        }
+        catch (error) {
+            if (!(error instanceof FeatureFlagVerificationError)) {
+                throw error;
+            }
+            resetPublicKeyCache();
+            this.publicKeyPem = await this.fetchPublicKey();
+            this.publicKeyCrypto = await importPublicKey(this.publicKeyPem);
+            return verifyFeatureFlagTokenDetailed({ token, publicKey: this.publicKeyCrypto });
+        }
+    }
+    async ensureVerificationKey() {
+        if (!this.publicKeyPem) {
+            this.publicKeyPem = await this.fetchPublicKey();
+        }
+        if (!this.publicKeyCrypto) {
+            this.publicKeyCrypto = await importPublicKey(this.publicKeyPem);
+        }
+    }
+    async getTrustedSnapshotVerificationKey() {
+        if (this.publicKeyPem) {
+            if (!this.publicKeyCrypto) {
+                this.publicKeyCrypto = await importPublicKey(this.publicKeyPem);
+            }
+            return {
+                publicKeyCrypto: this.publicKeyCrypto,
+                publicKeyPem: this.publicKeyPem,
+            };
+        }
+        try {
+            await this.ensureVerificationKey();
+        }
+        catch (error) {
+            if (error instanceof FeatureFlagNetworkError) {
+                return null;
+            }
+            throw error;
+        }
+        if (!this.publicKeyPem || !this.publicKeyCrypto) {
+            return null;
+        }
+        return {
+            publicKeyCrypto: this.publicKeyCrypto,
+            publicKeyPem: this.publicKeyPem,
+        };
+    }
+    async getSnapshotStore() {
+        if (!this.snapshotStorePromise) {
+            let snapshotPersistence;
+            if (this.snapshotPersistence === undefined) {
+                snapshotPersistence = { keyPrefix: this.keyPrefix };
+            }
+            else if (this.snapshotPersistence === false) {
+                snapshotPersistence = false;
+            }
+            else {
+                snapshotPersistence = {
+                    ...this.snapshotPersistence,
+                    keyPrefix: this.snapshotPersistence.keyPrefix ?? this.keyPrefix,
+                };
+            }
+            this.snapshotStorePromise = resolveSnapshotStore({
+                config: {
+                    apiUrl: this.apiUrl,
+                    clientKey: this.clientKey,
+                    environmentId: this.environmentId,
+                    organizationId: this.organizationId,
+                    teamId: this.teamId ?? undefined,
+                    evaluationContext: this.evaluationContext ?? undefined,
+                    snapshotPersistence,
+                },
+            });
+        }
+        return this.snapshotStorePromise;
+    }
+    async getScopeParts() {
+        return buildSnapshotScopeParts({
+            config: {
+                apiUrl: this.apiUrl,
+                clientKey: this.clientKey,
+                environmentId: this.environmentId,
+                organizationId: this.organizationId,
+                teamId: this.teamId ?? undefined,
+                evaluationContext: this.evaluationContext ?? undefined,
+            },
+            keyPrefix: this.keyPrefix,
+        });
+    }
+    async restorePersistedSnapshot() {
+        const store = await this.getSnapshotStore();
+        if (!store) {
+            return false;
+        }
+        const scope = await this.getScopeParts();
+        const snapshot = await store.load(scope.scopeKey);
+        if (!snapshot) {
+            return false;
+        }
+        if (!doesSnapshotMatchScope({ snapshot, scope })) {
+            await store.remove(scope.scopeKey);
+            return false;
+        }
+        const trustedKey = await this.getTrustedSnapshotVerificationKey();
+        if (!trustedKey) {
+            return false;
+        }
+        try {
+            const verified = await verifyFeatureFlagTokenDetailed({
+                token: snapshot.token,
+                publicKey: trustedKey.publicKeyCrypto,
+                allowExpired: true,
+            });
+            this.publicKeyPem = trustedKey.publicKeyPem;
+            this.publicKeyCrypto = trustedKey.publicKeyCrypto;
+            this.pendingScopeTransition = false;
+            const flagsChanged = this.updateFlags(verified.flags);
+            this.setRuntimeStatus({
+                source: "persisted",
+                tokenExpiresAt: verified.expiresAt,
+                lastSuccessfulRefreshAt: snapshot.fetchedAt,
+                lastError: null,
+            });
+            this.emitChange({ flagsChanged, storeChanged: true });
+            return true;
+        }
+        catch {
+            await store.remove(scope.scopeKey);
+            return false;
+        }
+    }
+    async persistSnapshot(params) {
+        const store = await this.getSnapshotStore();
+        if (!store || !this.publicKeyPem) {
+            return;
+        }
+        const scope = await this.getScopeParts();
+        const snapshot = createPersistedFeatureFlagSnapshot({
+            scope,
+            token: params.token,
+            publicKeyPem: this.publicKeyPem,
+            fetchedAt: params.fetchedAt,
+            tokenExpiresAt: params.tokenExpiresAt,
+        });
+        try {
+            await store.save(scope.scopeKey, snapshot);
+        }
+        catch (error) {
+            const wrappedError = error instanceof Error ? error : new Error("Failed to persist feature flag snapshot.");
+            this.onError?.(wrappedError);
+        }
+    }
+    startPolling() {
+        this.scheduleNextPoll();
+        if (typeof document !== "undefined") {
+            this.visibilityHandler = () => {
+                if (document.visibilityState === "hidden") {
+                    if (this.refreshTimer) {
+                        clearTimeout(this.refreshTimer);
+                        this.refreshTimer = null;
+                    }
+                }
+                else if (document.visibilityState === "visible") {
+                    void this.safeRefresh();
+                }
+            };
+            document.addEventListener("visibilitychange", this.visibilityHandler);
+        }
+    }
+    scheduleNextPoll() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+        }
+        const delay = this.backoffMs > 0 ? this.backoffMs : this.refreshInterval;
+        this.refreshTimer = setTimeout(() => {
+            void this.safeRefresh();
+        }, delay);
+    }
+    async safeRefresh() {
+        try {
+            await this.refresh();
+        }
+        catch {
+        }
+        finally {
+            const isPageVisible = typeof document === "undefined" || document.visibilityState !== "hidden";
+            if (this.initialized && this.refreshInterval > 0 && isPageVisible) {
+                this.scheduleNextPoll();
+            }
+        }
+    }
+    resetBackoff() {
+        this.backoffMs = 0;
+        this.consecutiveFailures = 0;
+    }
+    incrementBackoff() {
+        this.consecutiveFailures++;
+        this.backoffMs = Math.min(BACKOFF_BASE_MS * 2 ** (this.consecutiveFailures - 1), BACKOFF_CAP_MS);
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class FeatureFlagError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class FeatureFlagNetworkError extends FeatureFlagError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class FeatureFlagVerificationError extends FeatureFlagError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,18 @@
+export class FeatureFlagError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "FeatureFlagError";
+    }
+}
+export class FeatureFlagNetworkError extends FeatureFlagError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "FeatureFlagNetworkError";
+    }
+}
+export class FeatureFlagVerificationError extends FeatureFlagError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "FeatureFlagVerificationError";
+    }
+}

package/dist/index.cjs

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { MergedFeatureFlags } from "./client.js";
+export { FeatureFlagError, FeatureFlagNetworkError, FeatureFlagVerificationError } from "./errors.js";
+export { createDefaultFeatureFlagRuntimeStatus, createFileFeatureFlagSnapshotStore, createLocalStorageFeatureFlagSnapshotStore, } from "./persistence.js";
+export type { EvaluatedFlag, FeatureFlagEvaluationContext, FeatureFlagType, FeatureFlagDefinition, SignedEvaluateResponse, EvaluateResponse, PublicKeyResponse, FeatureFlagClientConfig, FeatureFlagRuntimeSource, FeatureFlagRuntimeStatus, FeatureFlagSnapshotPersistenceConfig, FeatureFlagSnapshotStore, FlagRegistry, GenerateConfig, PersistedFeatureFlagSnapshot, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { MergedFeatureFlags } from "./client.js";
+export { FeatureFlagError, FeatureFlagNetworkError, FeatureFlagVerificationError } from "./errors.js";
+export { createDefaultFeatureFlagRuntimeStatus, createFileFeatureFlagSnapshotStore, createLocalStorageFeatureFlagSnapshotStore, } from "./persistence.js";

package/dist/jwt.d.ts

@@ -0,0 +1,20 @@
+import type { EvaluatedFlag } from "@repo/types-v2";
+export declare function importPublicKey(pem: string): Promise<CryptoKey>;
+export declare function resetPublicKeyCache(): void;
+export type VerifiedFeatureFlagToken = {
+    flags: EvaluatedFlag[];
+    expiresAt: string | null;
+};
+export declare function verifyFeatureFlagTokenDetailed(params: {
+    token: string;
+    publicKey: CryptoKey;
+    allowExpired?: boolean;
+}): Promise<VerifiedFeatureFlagToken>;
+export declare function verifyFeatureFlagToken(params: {
+    token: string;
+    publicKey: CryptoKey;
+}): Promise<EvaluatedFlag[]>;
+export declare function verifyFeatureFlagTokenIgnoringExpiration(params: {
+    token: string;
+    publicKey: CryptoKey;
+}): Promise<VerifiedFeatureFlagToken>;

package/dist/jwt.js

@@ -0,0 +1,78 @@
+import { compactVerify, importSPKI, jwtVerify } from "jose";
+import { FeatureFlagVerificationError } from "./errors.js";
+const JWT_ALGORITHM = "ES256";
+const JWT_ISSUER = "merged";
+const JWT_TYPE = "feature_flag_values";
+let cachedKey = null;
+let cachedPem = null;
+export async function importPublicKey(pem) {
+    if (cachedPem === pem && cachedKey) {
+        return cachedKey;
+    }
+    try {
+        cachedKey = await importSPKI(pem, JWT_ALGORITHM);
+        cachedPem = pem;
+        return cachedKey;
+    }
+    catch (error) {
+        cachedKey = null;
+        cachedPem = null;
+        throw new FeatureFlagVerificationError("Failed to import public key.", { cause: error });
+    }
+}
+export function resetPublicKeyCache() {
+    cachedKey = null;
+    cachedPem = null;
+}
+export async function verifyFeatureFlagTokenDetailed(params) {
+    try {
+        if (!params.allowExpired) {
+            const { payload } = await jwtVerify(params.token, params.publicKey, {
+                algorithms: [JWT_ALGORITHM],
+                issuer: JWT_ISSUER,
+            });
+            return extractVerifiedTokenPayload(payload);
+        }
+        const { payload } = await compactVerify(params.token, params.publicKey, {
+            algorithms: [JWT_ALGORITHM],
+        });
+        const rawPayload = JSON.parse(new TextDecoder().decode(payload));
+        const notBefore = rawPayload.nbf;
+        if (typeof notBefore === "number" && Number.isFinite(notBefore) && Math.floor(Date.now() / 1000) < notBefore) {
+            throw new FeatureFlagVerificationError("JWT payload is not yet valid.");
+        }
+        return extractVerifiedTokenPayload(rawPayload);
+    }
+    catch (error) {
+        if (error instanceof FeatureFlagVerificationError) {
+            throw error;
+        }
+        throw new FeatureFlagVerificationError("JWT verification failed.", { cause: error });
+    }
+}
+export async function verifyFeatureFlagToken(params) {
+    const verified = await verifyFeatureFlagTokenDetailed(params);
+    return verified.flags;
+}
+export async function verifyFeatureFlagTokenIgnoringExpiration(params) {
+    return verifyFeatureFlagTokenDetailed({ ...params, allowExpired: true });
+}
+function extractVerifiedTokenPayload(payload) {
+    if (payload.iss !== JWT_ISSUER) {
+        throw new FeatureFlagVerificationError("JWT payload has an unexpected issuer.");
+    }
+    if (payload.type !== JWT_TYPE) {
+        throw new FeatureFlagVerificationError("JWT payload has an unexpected token type.");
+    }
+    const flags = payload.flags;
+    if (!Array.isArray(flags)) {
+        throw new FeatureFlagVerificationError("JWT payload does not contain a flags array.");
+    }
+    const expiresAt = typeof payload.exp === "number" && Number.isFinite(payload.exp)
+        ? new Date(payload.exp * 1000).toISOString()
+        : null;
+    return {
+        flags: flags,
+        expiresAt,
+    };
+}

package/dist/nestjs/bindings.d.ts

@@ -0,0 +1,5 @@
+import type { NativeFeatureFlagsModuleOptions, TypedNestjsBindings } from "./types.js";
+import type { FlagRegistry } from "../types.js";
+export declare function createTypedNestjsBindings<TFlags extends FlagRegistry>(params: {
+    flagIds: NonNullable<NativeFeatureFlagsModuleOptions<TFlags>["flagIds"]>;
+}): TypedNestjsBindings<TFlags>;

package/dist/nestjs/bindings.js

@@ -0,0 +1,33 @@
+import { FeatureFlagGate as BaseFeatureFlagGate, RequireFeatureFlag as BaseRequireFeatureFlag } from "./decorators.js";
+import { FeatureFlagsModule as BaseFeatureFlagsModule } from "./module.js";
+export function createTypedNestjsBindings(params) {
+    return {
+        FeatureFlagGate(options) {
+            return BaseFeatureFlagGate(options);
+        },
+        FeatureFlagsModule: {
+            forRoot(options) {
+                return BaseFeatureFlagsModule.forRoot({
+                    ...options,
+                    flagIds: params.flagIds,
+                });
+            },
+            forRootAsync(options) {
+                return BaseFeatureFlagsModule.forRootAsync({
+                    imports: options.imports,
+                    inject: options.inject,
+                    async useFactory(...args) {
+                        const resolvedOptions = await options.useFactory(...args);
+                        return {
+                            ...resolvedOptions,
+                            flagIds: params.flagIds,
+                        };
+                    },
+                });
+            },
+        },
+        RequireFeatureFlag(options) {
+            return BaseRequireFeatureFlag(options);
+        },
+    };
+}

package/dist/nestjs/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const FEATURE_FLAGS_MODULE_OPTIONS: unique symbol;
+export declare const FEATURE_FLAGS_EVALUATOR: unique symbol;
+export declare const FEATURE_FLAGS_REQUEST_CONTEXT: unique symbol;
+export declare const REQUIRE_FEATURE_FLAG_KEY = "REQUIRE_FEATURE_FLAG";