@mergedapp/feature-flags 0.1.3

package/dist/cjs/nestjs/context.js

@@ -0,0 +1,28 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagsRequestContextStore = void 0;
+exports.resolveFeatureFlagContext = resolveFeatureFlagContext;
+const node_async_hooks_1 = require("node:async_hooks");
+const common_1 = require("@nestjs/common");
+let FeatureFlagsRequestContextStore = class FeatureFlagsRequestContextStore {
+    storage = new node_async_hooks_1.AsyncLocalStorage();
+    getContext() {
+        return this.storage.getStore() ?? null;
+    }
+    run(context, callback) {
+        return this.storage.run(context ?? null, callback);
+    }
+};
+exports.FeatureFlagsRequestContextStore = FeatureFlagsRequestContextStore;
+exports.FeatureFlagsRequestContextStore = FeatureFlagsRequestContextStore = __decorate([
+    (0, common_1.Injectable)()
+], FeatureFlagsRequestContextStore);
+async function resolveFeatureFlagContext(params) {
+    return params.contextFactory ? params.contextFactory(params.context) : undefined;
+}

package/dist/cjs/nestjs/decorators.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagContext = void 0;
+exports.RequireFeatureFlag = RequireFeatureFlag;
+exports.FeatureFlagGate = FeatureFlagGate;
+const common_1 = require("@nestjs/common");
+const constants_js_1 = require("./constants.js");
+const errors_js_1 = require("./errors.js");
+const guard_js_1 = require("./guard.js");
+function RequireFeatureFlag(options) {
+    return (0, common_1.applyDecorators)((0, common_1.SetMetadata)(constants_js_1.REQUIRE_FEATURE_FLAG_KEY, options), (0, common_1.UseGuards)(guard_js_1.FeatureFlagGuard));
+}
+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 (0, guard_js_1.evaluateGate)({
+                context,
+                defaultValue: options.defaultValue ?? false,
+                expectedValue: options.expectedValue,
+                featureFlagsService,
+                flagKey: options.flagKey,
+            });
+            if (!allowed) {
+                throw new errors_js_1.FeatureFlagGateError({ flagKey: options.flagKey });
+            }
+            return original.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+exports.FeatureFlagContext = (0, common_1.createParamDecorator)((_data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request?.[constants_js_1.FEATURE_FLAGS_REQUEST_CONTEXT] ?? null;
+});
+function isFeatureFlagsService(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "getDetails" in value &&
+        typeof value.getDetails === "function");
+}

package/dist/cjs/nestjs/errors.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagGateError = exports.FeatureFlagDisabledHttpException = void 0;
+const common_1 = require("@nestjs/common");
+class FeatureFlagDisabledHttpException extends common_1.HttpException {
+    constructor({ flagKey, message }) {
+        super({
+            code: "FEATURE_FLAG_DISABLED",
+            error: "FEATURE_FLAG_DISABLED",
+            message: message ?? `Feature flag (${flagKey}) is disabled for this request.`,
+            statusCode: common_1.HttpStatus.FORBIDDEN,
+        }, common_1.HttpStatus.FORBIDDEN);
+    }
+}
+exports.FeatureFlagDisabledHttpException = FeatureFlagDisabledHttpException;
+class FeatureFlagGateError extends FeatureFlagDisabledHttpException {
+    constructor({ flagKey }) {
+        super({
+            flagKey,
+            message: `Feature flag (${flagKey}) blocked this service method.`,
+        });
+        this.name = "FeatureFlagGateError";
+    }
+}
+exports.FeatureFlagGateError = FeatureFlagGateError;

package/dist/cjs/nestjs/evaluator.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeNestFeatureFlagsEvaluator = void 0;
+const remote_evaluator_js_1 = require("../remote-evaluator.js");
+class NativeNestFeatureFlagsEvaluator {
+    options;
+    evaluator;
+    constructor(options) {
+        this.options = options;
+        this.evaluator = new remote_evaluator_js_1.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,
+        };
+    }
+}
+exports.NativeNestFeatureFlagsEvaluator = NativeNestFeatureFlagsEvaluator;
+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/cjs/nestjs/guard.js

@@ -0,0 +1,67 @@
+"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;
+exports.evaluateGate = evaluateGate;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_js_1 = require("./constants.js");
+const context_js_1 = require("./context.js");
+const errors_js_1 = require("./errors.js");
+const service_js_1 = require("./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(constants_js_1.REQUIRE_FEATURE_FLAG_KEY, [context.getHandler(), context.getClass()]);
+        if (!metadata) {
+            return true;
+        }
+        const evaluationContext = metadata.contextFactory
+            ? await (0, context_js_1.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 errors_js_1.FeatureFlagDisabledHttpException({ flagKey: metadata.flagKey });
+        }
+        return true;
+    }
+};
+exports.FeatureFlagGuard = FeatureFlagGuard;
+exports.FeatureFlagGuard = FeatureFlagGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        service_js_1.FeatureFlagsService])
+], FeatureFlagGuard);
+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/cjs/nestjs/interceptor.js

@@ -0,0 +1,56 @@
+"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.FeatureFlagContextInterceptor = void 0;
+const rxjs_1 = require("rxjs");
+const common_1 = require("@nestjs/common");
+const constants_js_1 = require("./constants.js");
+const context_js_1 = require("./context.js");
+let FeatureFlagContextInterceptor = class FeatureFlagContextInterceptor {
+    options;
+    requestContextStore;
+    constructor(options, requestContextStore) {
+        this.options = options;
+        this.requestContextStore = requestContextStore;
+    }
+    async intercept(context, next) {
+        const evaluationContext = await (0, context_js_1.resolveFeatureFlagContext)({
+            context,
+            contextFactory: this.options.contextFactory,
+        });
+        const request = context.switchToHttp().getRequest();
+        if (request) {
+            request[constants_js_1.FEATURE_FLAGS_REQUEST_CONTEXT] = evaluationContext ?? null;
+        }
+        return new rxjs_1.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();
+            };
+        });
+    }
+};
+exports.FeatureFlagContextInterceptor = FeatureFlagContextInterceptor;
+exports.FeatureFlagContextInterceptor = FeatureFlagContextInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.FEATURE_FLAGS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, context_js_1.FeatureFlagsRequestContextStore])
+], FeatureFlagContextInterceptor);

package/dist/cjs/nestjs/module.js

@@ -0,0 +1,70 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagsModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_js_1 = require("./constants.js");
+const context_js_1 = require("./context.js");
+const evaluator_js_1 = require("./evaluator.js");
+const guard_js_1 = require("./guard.js");
+const interceptor_js_1 = require("./interceptor.js");
+const service_js_1 = require("./service.js");
+let FeatureFlagsModule = class FeatureFlagsModule {
+    static forRoot(options) {
+        return createFeatureFlagsModule({
+            provideOptions: {
+                provide: constants_js_1.FEATURE_FLAGS_MODULE_OPTIONS,
+                useValue: options,
+            },
+        });
+    }
+    static forRootAsync(options) {
+        return createFeatureFlagsModule({
+            imports: options.imports ?? [],
+            provideOptions: {
+                provide: constants_js_1.FEATURE_FLAGS_MODULE_OPTIONS,
+                inject: options.inject ?? [],
+                useFactory: options.useFactory,
+            },
+        });
+    }
+};
+exports.FeatureFlagsModule = FeatureFlagsModule;
+exports.FeatureFlagsModule = FeatureFlagsModule = __decorate([
+    (0, common_1.Module)({})
+], FeatureFlagsModule);
+function createFeatureFlagsModule(params) {
+    return {
+        module: FeatureFlagsModule,
+        imports: params.imports ?? [],
+        providers: [
+            params.provideOptions,
+            context_js_1.FeatureFlagsRequestContextStore,
+            service_js_1.FeatureFlagsService,
+            guard_js_1.FeatureFlagGuard,
+            interceptor_js_1.FeatureFlagContextInterceptor,
+            {
+                provide: constants_js_1.FEATURE_FLAGS_EVALUATOR,
+                inject: [constants_js_1.FEATURE_FLAGS_MODULE_OPTIONS],
+                useFactory: (options) => new evaluator_js_1.NativeNestFeatureFlagsEvaluator(options),
+            },
+            {
+                provide: core_1.APP_INTERCEPTOR,
+                inject: [constants_js_1.FEATURE_FLAGS_MODULE_OPTIONS, interceptor_js_1.FeatureFlagContextInterceptor],
+                useFactory: (options, interceptor) => options.useGlobalInterceptor === false ? new PassthroughInterceptor() : interceptor,
+            },
+        ],
+        exports: [context_js_1.FeatureFlagsRequestContextStore, service_js_1.FeatureFlagsService, guard_js_1.FeatureFlagGuard, interceptor_js_1.FeatureFlagContextInterceptor],
+    };
+}
+class PassthroughInterceptor {
+    intercept(_context, next) {
+        return next.handle();
+    }
+}

package/dist/cjs/nestjs/service.js

@@ -0,0 +1,54 @@
+"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.FeatureFlagsService = void 0;
+const common_1 = require("@nestjs/common");
+const constants_js_1 = require("./constants.js");
+const context_js_1 = require("./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;
+    }
+};
+exports.FeatureFlagsService = FeatureFlagsService;
+exports.FeatureFlagsService = FeatureFlagsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.FEATURE_FLAGS_EVALUATOR)),
+    __metadata("design:paramtypes", [Object, context_js_1.FeatureFlagsRequestContextStore])
+], FeatureFlagsService);

package/dist/cjs/nestjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/nestjs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagsService = exports.FeatureFlagsModule = exports.FeatureFlagContextInterceptor = exports.evaluateGate = exports.FeatureFlagGuard = exports.NativeNestFeatureFlagsEvaluator = exports.FeatureFlagGateError = exports.FeatureFlagDisabledHttpException = exports.resolveFeatureFlagContext = exports.FeatureFlagsRequestContextStore = exports.RequireFeatureFlag = exports.FeatureFlagGate = exports.FeatureFlagContext = exports.createTypedNestjsBindings = void 0;
+var bindings_js_1 = require("./nestjs/bindings.js");
+Object.defineProperty(exports, "createTypedNestjsBindings", { enumerable: true, get: function () { return bindings_js_1.createTypedNestjsBindings; } });
+var decorators_js_1 = require("./nestjs/decorators.js");
+Object.defineProperty(exports, "FeatureFlagContext", { enumerable: true, get: function () { return decorators_js_1.FeatureFlagContext; } });
+Object.defineProperty(exports, "FeatureFlagGate", { enumerable: true, get: function () { return decorators_js_1.FeatureFlagGate; } });
+Object.defineProperty(exports, "RequireFeatureFlag", { enumerable: true, get: function () { return decorators_js_1.RequireFeatureFlag; } });
+var context_js_1 = require("./nestjs/context.js");
+Object.defineProperty(exports, "FeatureFlagsRequestContextStore", { enumerable: true, get: function () { return context_js_1.FeatureFlagsRequestContextStore; } });
+Object.defineProperty(exports, "resolveFeatureFlagContext", { enumerable: true, get: function () { return context_js_1.resolveFeatureFlagContext; } });
+var errors_js_1 = require("./nestjs/errors.js");
+Object.defineProperty(exports, "FeatureFlagDisabledHttpException", { enumerable: true, get: function () { return errors_js_1.FeatureFlagDisabledHttpException; } });
+Object.defineProperty(exports, "FeatureFlagGateError", { enumerable: true, get: function () { return errors_js_1.FeatureFlagGateError; } });
+var evaluator_js_1 = require("./nestjs/evaluator.js");
+Object.defineProperty(exports, "NativeNestFeatureFlagsEvaluator", { enumerable: true, get: function () { return evaluator_js_1.NativeNestFeatureFlagsEvaluator; } });
+var guard_js_1 = require("./nestjs/guard.js");
+Object.defineProperty(exports, "FeatureFlagGuard", { enumerable: true, get: function () { return guard_js_1.FeatureFlagGuard; } });
+Object.defineProperty(exports, "evaluateGate", { enumerable: true, get: function () { return guard_js_1.evaluateGate; } });
+var interceptor_js_1 = require("./nestjs/interceptor.js");
+Object.defineProperty(exports, "FeatureFlagContextInterceptor", { enumerable: true, get: function () { return interceptor_js_1.FeatureFlagContextInterceptor; } });
+var module_js_1 = require("./nestjs/module.js");
+Object.defineProperty(exports, "FeatureFlagsModule", { enumerable: true, get: function () { return module_js_1.FeatureFlagsModule; } });
+var service_js_1 = require("./nestjs/service.js");
+Object.defineProperty(exports, "FeatureFlagsService", { enumerable: true, get: function () { return service_js_1.FeatureFlagsService; } });

package/dist/cjs/openfeature/context.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TARGETING_KEY_ATTRIBUTE = void 0;
+exports.mapOpenFeatureContextValue = mapOpenFeatureContextValue;
+exports.createDefaultOpenFeatureContextMapper = createDefaultOpenFeatureContextMapper;
+exports.mergeFeatureFlagEvaluationContexts = mergeFeatureFlagEvaluationContexts;
+exports.DEFAULT_TARGETING_KEY_ATTRIBUTE = "subject.key";
+const UNSAFE_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const CYCLIC_CONTEXT_ERROR_MESSAGE = "Cyclic feature flag evaluation context is not allowed.";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isSafeObjectKey(key) {
+    return !UNSAFE_OBJECT_KEYS.has(key);
+}
+function createAttributeRecord() {
+    return Object.create(null);
+}
+function beginTraversal(value, visited) {
+    if (visited.has(value)) {
+        throw new TypeError(CYCLIC_CONTEXT_ERROR_MESSAGE);
+    }
+    visited.add(value);
+}
+function assertAcyclicFeatureFlagContextValue(value, visited = new WeakSet()) {
+    if (Array.isArray(value)) {
+        beginTraversal(value, visited);
+        try {
+            for (const entry of value) {
+                assertAcyclicFeatureFlagContextValue(entry, visited);
+            }
+        }
+        finally {
+            visited.delete(value);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    beginTraversal(value, visited);
+    try {
+        for (const [key, entry] of Object.entries(value)) {
+            if (!isSafeObjectKey(key)) {
+                continue;
+            }
+            assertAcyclicFeatureFlagContextValue(entry, visited);
+        }
+    }
+    finally {
+        visited.delete(value);
+    }
+}
+function setNestedAttribute(target, path, value) {
+    const segments = path.split(".").filter(Boolean);
+    const head = segments[0];
+    if (!head || !isSafeObjectKey(head)) {
+        return;
+    }
+    const tail = segments.slice(1);
+    if (tail.length === 0) {
+        target[head] = value;
+        return;
+    }
+    const nextTarget = isRecord(target[head]) ? target[head] : createAttributeRecord();
+    target[head] = nextTarget;
+    setNestedAttribute(nextTarget, tail.join("."), value);
+}
+function mergeAttributeValue(left, right, visited = new WeakSet()) {
+    if (isRecord(left) && isRecord(right)) {
+        beginTraversal(left, visited);
+        if (right !== left) {
+            beginTraversal(right, visited);
+        }
+        const merged = createAttributeRecord();
+        try {
+            for (const [key, value] of Object.entries(left)) {
+                if (!isSafeObjectKey(key)) {
+                    continue;
+                }
+                merged[key] = value;
+            }
+            for (const [key, value] of Object.entries(right)) {
+                if (!isSafeObjectKey(key)) {
+                    continue;
+                }
+                merged[key] = typeof merged[key] === "undefined" ? value : mergeAttributeValue(merged[key], value, visited);
+            }
+        }
+        finally {
+            visited.delete(left);
+            if (right !== left) {
+                visited.delete(right);
+            }
+        }
+        return merged;
+    }
+    return right;
+}
+function mapOpenFeatureContextValue(value, visited = new WeakSet()) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        beginTraversal(value, visited);
+        try {
+            return value.map((entry) => mapOpenFeatureContextValue(entry, visited));
+        }
+        finally {
+            visited.delete(value);
+        }
+    }
+    if (value && typeof value === "object") {
+        beginTraversal(value, visited);
+        const mapped = createAttributeRecord();
+        try {
+            for (const [key, entry] of Object.entries(value)) {
+                if (!isSafeObjectKey(key)) {
+                    continue;
+                }
+                mapped[key] = mapOpenFeatureContextValue(entry, visited);
+            }
+        }
+        finally {
+            visited.delete(value);
+        }
+        return mapped;
+    }
+    return value;
+}
+function createDefaultOpenFeatureContextMapper(params) {
+    const targetingKeyAttribute = params?.targetingKeyAttribute ?? exports.DEFAULT_TARGETING_KEY_ATTRIBUTE;
+    return (context) => {
+        const attributes = createAttributeRecord();
+        if (context.targetingKey) {
+            setNestedAttribute(attributes, targetingKeyAttribute, context.targetingKey);
+        }
+        for (const [key, value] of Object.entries(context)) {
+            if (key === "targetingKey" || typeof value === "undefined") {
+                continue;
+            }
+            if (!isSafeObjectKey(key)) {
+                continue;
+            }
+            attributes[key] = mapOpenFeatureContextValue(value);
+        }
+        return Object.keys(attributes).length > 0 ? { attributes } : null;
+    };
+}
+function mergeFeatureFlagEvaluationContexts(...contexts) {
+    const mergedAttributes = createAttributeRecord();
+    for (const context of contexts) {
+        if (!context?.attributes) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(context.attributes)) {
+            if (!isSafeObjectKey(key)) {
+                continue;
+            }
+            assertAcyclicFeatureFlagContextValue(value);
+            mergedAttributes[key] =
+                typeof mergedAttributes[key] === "undefined" ? value : mergeAttributeValue(mergedAttributes[key], value);
+        }
+    }
+    return Object.keys(mergedAttributes).length > 0 ? { attributes: mergedAttributes } : null;
+}

package/dist/cjs/openfeature/hooks.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStaticContextHook = createStaticContextHook;
+exports.createLoggingHook = createLoggingHook;
+function createStaticContextHook(context) {
+    return {
+        before() {
+            return context;
+        },
+    };
+}
+function createLoggingHook(params) {
+    const prefix = params.prefix ?? "feature-flags";
+    return {
+        after(hookContext, evaluationDetails, hookHints) {
+            params.logger.debug(`[${prefix}] evaluated flag (${hookContext.flagKey})`, {
+                defaultValue: hookContext.defaultValue,
+                errorCode: evaluationDetails.errorCode,
+                hookHints,
+                reason: evaluationDetails.reason,
+                value: evaluationDetails.value,
+            });
+        },
+        error(hookContext, error, hookHints) {
+            params.logger.error(`[${prefix}] failed evaluating flag (${hookContext.flagKey})`, {
+                error,
+                hookHints,
+            });
+        },
+    };
+}