@decaf-ts/integrations 0.4.0 → 0.4.1-0

package/lib/esm/feature-flags/environment.js

@@ -0,0 +1,18 @@
+import { LoggedEnvironment } from "@decaf-ts/logging";
+import { FEATURE_FLAG_ENV_ROOT, FEATURE_FLAG_ENV_PREFIX, } from "./constants.js";
+import { normalizeFeatureName, normalizeFeatureRegistry } from "./utils.js";
+export const FeatureFlagEnvironment = LoggedEnvironment.accumulate({
+    [FEATURE_FLAG_ENV_ROOT]: {},
+});
+export async function loadFeatureFlagsFromEnvironment(source = FeatureFlagEnvironment) {
+    return normalizeFeatureRegistry(source.featureFlag);
+}
+export async function resolveFeatureFlagFromEnvironment(featureName, source = FeatureFlagEnvironment) {
+    const registry = await loadFeatureFlagsFromEnvironment(source);
+    return registry[normalizeFeatureName(featureName)];
+}
+export async function hasFeatureFlagInEnvironment(featureName, source = FeatureFlagEnvironment) {
+    return !!(await resolveFeatureFlagFromEnvironment(featureName, source));
+}
+export { FEATURE_FLAG_ENV_PREFIX, FEATURE_FLAG_ENV_ROOT };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/feature-flags/index.js

@@ -0,0 +1,14 @@
+/**
+ * @module integrations/feature-flags
+ * @summary Feature-flag models, services, decorators, and environment helpers.
+ */
+export * from "./constants.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./environment.js";
+export * from "./models/FeatureFlag.model.js";
+export * from "./models/FeatureFlagAccess.model.js";
+export * from "./readers/index.js";
+export * from "./services/FeatureFlag.service.js";
+export * from "./decorators.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZmVhdHVyZS1mbGFncy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCwrQkFBNEI7QUFDNUIsMkJBQXdCO0FBQ3hCLDJCQUF3QjtBQUN4QixpQ0FBOEI7QUFDOUIsOENBQTJDO0FBQzNDLG9EQUFpRDtBQUNqRCxtQ0FBMEI7QUFDMUIsa0RBQStDO0FBQy9DLGdDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZmVhdHVyZS1mbGFnc1xuICogQHN1bW1hcnkgRmVhdHVyZS1mbGFnIG1vZGVscywgc2VydmljZXMsIGRlY29yYXRvcnMsIGFuZCBlbnZpcm9ubWVudCBoZWxwZXJzLlxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbnZpcm9ubWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxzL0ZlYXR1cmVGbGFnLm1vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2RlbHMvRmVhdHVyZUZsYWdBY2Nlc3MubW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3JlYWRlcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcnZpY2VzL0ZlYXR1cmVGbGFnLnNlcnZpY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbiJdfQ==

package/lib/esm/feature-flags/models/FeatureFlag.model.js

@@ -0,0 +1,72 @@
+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 { BaseModel } from "@decaf-ts/core";
+import { column, createdAt, pk, table, updatedAt, uuid, unique, } from "@decaf-ts/core";
+import { model, required } from "@decaf-ts/decorator-validation";
+let FeatureFlag = class FeatureFlag extends BaseModel {
+    constructor(data) {
+        super(data);
+        this.enabled = true;
+    }
+};
+__decorate([
+    pk(),
+    uuid(),
+    __metadata("design:type", String)
+], FeatureFlag.prototype, "id", void 0);
+__decorate([
+    unique(),
+    required(),
+    column(),
+    __metadata("design:type", String)
+], FeatureFlag.prototype, "key", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Boolean)
+], FeatureFlag.prototype, "enabled", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], FeatureFlag.prototype, "description", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], FeatureFlag.prototype, "scope", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Object)
+], FeatureFlag.prototype, "metadata", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Object)
+], FeatureFlag.prototype, "config", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], FeatureFlag.prototype, "createdBy", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], FeatureFlag.prototype, "updatedBy", void 0);
+__decorate([
+    createdAt(),
+    __metadata("design:type", Date)
+], FeatureFlag.prototype, "createdAt", void 0);
+__decorate([
+    updatedAt(),
+    __metadata("design:type", Date)
+], FeatureFlag.prototype, "updatedAt", void 0);
+FeatureFlag = __decorate([
+    table("feature_flags"),
+    model(),
+    __metadata("design:paramtypes", [Object])
+], FeatureFlag);
+export { FeatureFlag };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/feature-flags/models/FeatureFlagAccess.model.js

@@ -0,0 +1,69 @@
+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 { BaseModel } from "@decaf-ts/core";
+import { column, createdAt, pk, table, updatedAt, uuid } from "@decaf-ts/core";
+import { model, required } from "@decaf-ts/decorator-validation";
+let FeatureFlagAccess = class FeatureFlagAccess extends BaseModel {
+    constructor(data) {
+        super(data);
+        this.enabled = true;
+    }
+};
+__decorate([
+    pk(),
+    uuid(),
+    __metadata("design:type", String)
+], FeatureFlagAccess.prototype, "id", void 0);
+__decorate([
+    required(),
+    column(),
+    __metadata("design:type", String)
+], FeatureFlagAccess.prototype, "featureKey", void 0);
+__decorate([
+    required(),
+    column(),
+    __metadata("design:type", String)
+], FeatureFlagAccess.prototype, "subjectType", void 0);
+__decorate([
+    required(),
+    column(),
+    __metadata("design:type", String)
+], FeatureFlagAccess.prototype, "subjectKey", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Boolean)
+], FeatureFlagAccess.prototype, "enabled", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Object)
+], FeatureFlagAccess.prototype, "metadata", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], FeatureFlagAccess.prototype, "createdBy", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], FeatureFlagAccess.prototype, "updatedBy", void 0);
+__decorate([
+    createdAt(),
+    __metadata("design:type", Date)
+], FeatureFlagAccess.prototype, "createdAt", void 0);
+__decorate([
+    updatedAt(),
+    __metadata("design:type", Date)
+], FeatureFlagAccess.prototype, "updatedAt", void 0);
+FeatureFlagAccess = __decorate([
+    table("feature_flag_access"),
+    model(),
+    __metadata("design:paramtypes", [Object])
+], FeatureFlagAccess);
+export { FeatureFlagAccess };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/feature-flags/readers/FeatureFlagReader.js

@@ -0,0 +1,19 @@
+import { FEATURE_FLAG_ENV_ROOT, } from "./../constants.js";
+import { loadFeatureFlagsFromEnvironment, } from "./../environment.js";
+import { normalizeFeatureName } from "./../utils.js";
+export class FeatureFlagReader {
+    async readOne(featureName, input) {
+        const registry = await this.read(input);
+        return registry[normalizeFeatureName(featureName)];
+    }
+}
+export class EnvironmeFlagReader extends FeatureFlagReader {
+    async read(input = {}) {
+        const environment = input.source ??
+            {
+                [FEATURE_FLAG_ENV_ROOT]: {},
+            };
+        return loadFeatureFlagsFromEnvironment(environment);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/feature-flags/readers/index.js

@@ -0,0 +1,2 @@
+export * from "./FeatureFlagReader.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZmVhdHVyZS1mbGFncy9yZWFkZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHVDQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0ZlYXR1cmVGbGFnUmVhZGVyXCI7XG5cbiJdfQ==

package/lib/esm/feature-flags/services/FeatureFlag.service.js

@@ -0,0 +1,250 @@
+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 { Condition, ModelService, Repository, repository, service, } from "@decaf-ts/core";
+import { NotFoundError } from "@decaf-ts/db-decorators";
+import { FeatureFlagEnvironment } from "./../environment.js";
+import { FeatureFlagAccess } from "./../models/FeatureFlagAccess.model.js";
+import { FeatureFlag } from "./../models/FeatureFlag.model.js";
+import { EnvironmeFlagReader, } from "./../readers/index.js";
+import { isFeatureFlagEnabled, isFeatureFlagEnabledByName, normalizeFeatureName, } from "./../utils.js";
+import { normalizeFeatureSubjectKey, normalizeFeatureSubjectType } from "./../utils.js";
+let FeatureFlagService = class FeatureFlagService extends ModelService {
+    constructor() {
+        super(FeatureFlag);
+        this.reader = new EnvironmeFlagReader();
+        this.cachedRegistry = {};
+    }
+    async initialize(...args) {
+        const config = args[0] ?? {};
+        if (config.repository) {
+            this._repository = config.repository;
+        }
+        this.reader = !config.reader
+            ? new EnvironmeFlagReader()
+            : typeof config.reader === "function"
+                ? new config.reader()
+                : config.reader;
+        const readerConfig = {
+            ...(config.readerConfig ?? {}),
+            source: config.readerConfig?.source ?? FeatureFlagEnvironment,
+        };
+        this.cachedRegistry = await this.refreshCachedRegistry(readerConfig, ...args);
+        const effectiveConfig = {
+            ...config,
+            reader: this.reader,
+            readerConfig,
+        };
+        return { config: effectiveConfig, client: this.reader };
+    }
+    cloneRegistry(registry) {
+        return Object.entries(registry).reduce((acc, [key, value]) => {
+            acc[key] =
+                value && typeof value === "object" && !Array.isArray(value)
+                    ? { ...value }
+                    : value;
+            return acc;
+        }, {});
+    }
+    async refreshCachedRegistry(options = {}, ...args) {
+        const envRegistry = await this.reader.read({
+            ...options,
+            source: options.source ?? FeatureFlagEnvironment,
+        });
+        let persisted = [];
+        try {
+            persisted = await this.repo.select().execute(...args);
+        }
+        catch {
+            persisted = [];
+        }
+        const registry = this.cloneRegistry(envRegistry);
+        for (const flag of persisted) {
+            registry[flag.key] = flag.enabled ? (flag.config ?? true) : false;
+        }
+        return registry;
+    }
+    setCachedFlag(flag) {
+        this.cachedRegistry[flag.key] = flag.enabled
+            ? (flag.config ?? true)
+            : false;
+    }
+    getAccessRepository() {
+        return this.accessRepository ?? Repository.forModel(FeatureFlagAccess);
+    }
+    assertInitialized() {
+        void this.reader;
+    }
+    normalizeFeatureAccessInput(input) {
+        return {
+            ...input,
+            featureKey: normalizeFeatureName(input.featureKey),
+            subjectType: normalizeFeatureSubjectType(input.subjectType),
+            subjectKey: normalizeFeatureSubjectKey(input.subjectKey),
+        };
+    }
+    buildAccessCondition(query) {
+        let condition = Condition.attr("subjectType").eq(normalizeFeatureSubjectType(query.subjectType));
+        condition = condition.and(Condition.attr("subjectKey").eq(normalizeFeatureSubjectKey(query.subjectKey)));
+        if (typeof query.enabled !== "undefined") {
+            condition = condition.and(Condition.attr("enabled").eq(query.enabled));
+        }
+        if (query.featureKeys && query.featureKeys.length > 0) {
+            condition = condition.and(Condition.attr("featureKey").in(query.featureKeys.map(normalizeFeatureName)));
+        }
+        return condition;
+    }
+    async create(model, ...args) {
+        model.key = normalizeFeatureName(model.key);
+        model.enabled ??= true;
+        const created = await super.create(model, ...args);
+        this.setCachedFlag(created);
+        return created;
+    }
+    async update(model, ...args) {
+        model.key = normalizeFeatureName(model.key);
+        model.enabled ??= true;
+        const updated = await super.update(model, ...args);
+        this.setCachedFlag(updated);
+        return updated;
+    }
+    async findOneBy(key, value, ...args) {
+        const normalizedValue = key === "key" && typeof value === "string"
+            ? normalizeFeatureName(value)
+            : value;
+        return this.repo.findOneBy(key, normalizedValue, ...args);
+    }
+    async readAll(keys, ...args) {
+        const result = await this.repo.readAll(keys, ...args);
+        for (const flag of result)
+            this.setCachedFlag(flag);
+        return result;
+    }
+    async listEnabled(...args) {
+        return this.repo
+            .select()
+            .where(Condition.attr("enabled").eq(true))
+            .execute(...args);
+    }
+    async grantFeatureAccess(input, ...args) {
+        const normalized = this.normalizeFeatureAccessInput(input);
+        const existing = await this.findFeatureAccess(normalized, ...args).catch(() => undefined);
+        if (!existing) {
+            return this.getAccessRepository().create(new FeatureFlagAccess(normalized), ...args);
+        }
+        return this.getAccessRepository().update(Object.assign(existing, normalized), ...args);
+    }
+    async revokeFeatureAccess(input, ...args) {
+        const existing = await this.findFeatureAccess(input, ...args).catch(() => undefined);
+        if (!existing)
+            return undefined;
+        return this.getAccessRepository().delete(existing.id, ...args);
+    }
+    async findFeatureAccess(query, ...args) {
+        const condition = this.buildAccessCondition(query);
+        const results = await this.getAccessRepository()
+            .select()
+            .where(condition)
+            .execute(...args);
+        const existing = results[0];
+        if (!existing) {
+            throw new NotFoundError(`Feature access for ${normalizeFeatureSubjectType(query.subjectType)}:${normalizeFeatureSubjectKey(query.subjectKey)} not found`);
+        }
+        return existing;
+    }
+    async listFeatureAccess(query, ...args) {
+        return this.getAccessRepository()
+            .select()
+            .where(this.buildAccessCondition(query))
+            .execute(...args);
+    }
+    async resolveFeatureFlagsForSubject(subject, ...args) {
+        this.assertInitialized();
+        const access = await this.listFeatureAccess({
+            ...subject,
+            enabled: true,
+        }, ...args);
+        const featureKeys = [...new Set(access.map((item) => item.featureKey))];
+        if (featureKeys.length === 0)
+            return {};
+        const condition = Condition.attr("enabled").eq(true).and(Condition.attr("key").in(featureKeys.map(normalizeFeatureName)));
+        const enabledFlags = await this.repo.select().where(condition).execute(...args);
+        return enabledFlags.reduce((registry, flag) => {
+            registry[flag.key] = flag.config ?? true;
+            return registry;
+        }, {});
+    }
+    async isEnabledForSubject(key, subject, ...args) {
+        const registry = await this.resolveFeatureFlagsForSubject(subject, ...args);
+        return isFeatureFlagEnabledByName(registry, key);
+    }
+    isEnabled(key) {
+        this.assertInitialized();
+        const normalizedKey = normalizeFeatureName(key);
+        return isFeatureFlagEnabledByName(this.cachedRegistry, normalizedKey);
+    }
+    async resolveFeatureFlags() {
+        this.assertInitialized();
+        return this.cloneRegistry(this.cachedRegistry);
+    }
+    async syncFromEnvironment(options = {}, ...args) {
+        this.assertInitialized();
+        const registry = await this.reader.read({
+            ...options,
+            source: options.source ?? FeatureFlagEnvironment,
+        });
+        const results = [];
+        for (const [key, value] of Object.entries(registry)) {
+            const config = value && typeof value === "object" && !Array.isArray(value)
+                ? value
+                : { enabled: Boolean(value) };
+            const { enabled: _ignoredEnabled, ...restConfig } = config;
+            const normalizedKey = normalizeFeatureName(key);
+            const existing = await this.findOneBy("key", normalizedKey, ...args).catch(() => undefined);
+            const model = existing
+                ? Object.assign(existing, {
+                    enabled: isFeatureFlagEnabled(value),
+                    description: restConfig.description ?? existing.description,
+                    scope: restConfig.scope ?? existing.scope,
+                    metadata: restConfig.metadata ?? existing.metadata,
+                    config: {
+                        ...restConfig,
+                        enabled: isFeatureFlagEnabled(value),
+                    },
+                })
+                : new FeatureFlag({
+                    key: normalizedKey,
+                    enabled: isFeatureFlagEnabled(value),
+                    description: restConfig.description,
+                    scope: restConfig.scope,
+                    metadata: restConfig.metadata,
+                    config: {
+                        ...restConfig,
+                        enabled: isFeatureFlagEnabled(value),
+                    },
+                });
+            results.push(existing ? await this.update(model, ...args) : await this.create(model, ...args));
+        }
+        this.cachedRegistry = await this.refreshCachedRegistry({
+            ...options,
+            source: options.source ?? FeatureFlagEnvironment,
+        }, ...args);
+        return results;
+    }
+};
+__decorate([
+    repository(FeatureFlagAccess),
+    __metadata("design:type", Object)
+], FeatureFlagService.prototype, "accessRepository", void 0);
+FeatureFlagService = __decorate([
+    service(FeatureFlag),
+    __metadata("design:paramtypes", [])
+], FeatureFlagService);
+export { FeatureFlagService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FeatureFlag.service.js","sourceRoot":"","sources":["../../../../src/feature-flags/services/FeatureFlag.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Condition,\n  ModelService,\n  Repository,\n  repository,\n  service,\n} from \"@decaf-ts/core\";\nimport type { Repo } from \"@decaf-ts/core\";\nimport { NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { FeatureFlagEnvironment } from \"../environment\";\nimport { FeatureFlagAccess } from \"../models/FeatureFlagAccess.model\";\nimport { FeatureFlag } from \"../models/FeatureFlag.model\";\nimport {\n  EnvironmeFlagReader,\n  FeatureFlagReader,\n  FeatureFlagReaderLike,\n} from \"../readers\";\nimport type {\n  FeatureFlagAccessInput,\n  FeatureFlagAccessQuery,\n  FeatureFlagAccessSubject,\n  FeatureFlagConfig,\n  FeatureFlagReaderConfig,\n  FeatureFlagReaderInput,\n  FeatureFlagRegistry,\n} from \"../types\";\nimport {\n  isFeatureFlagEnabled,\n  isFeatureFlagEnabledByName,\n  normalizeFeatureName,\n} from \"../utils\";\nimport { normalizeFeatureSubjectKey, normalizeFeatureSubjectType } from \"../utils\";\n\nexport interface FeatureFlagServiceConfig extends FeatureFlagReaderConfig {\n  reader?: FeatureFlagReaderLike;\n  repository?: Repository<FeatureFlag, any>;\n}\n\n@service(FeatureFlag)\nexport class FeatureFlagService extends ModelService<FeatureFlag> {\n  private reader: FeatureFlagReader = new EnvironmeFlagReader();\n  private cachedRegistry: FeatureFlagRegistry = {};\n  @repository(FeatureFlagAccess)\n  protected accessRepository!: Repo<FeatureFlagAccess>;\n\n  constructor() {\n    super(FeatureFlag);\n  }\n\n  async initialize(\n    ...args: any[]\n  ): Promise<{ config: FeatureFlagServiceConfig; client: FeatureFlagReader }> {\n    const config = (args[0] as FeatureFlagServiceConfig | undefined) ?? {};\n    if (config.repository) {\n      this._repository = config.repository as any;\n    }\n    this.reader = !config.reader\n      ? new EnvironmeFlagReader()\n      : typeof config.reader === \"function\"\n        ? new config.reader()\n        : config.reader;\n    const readerConfig = {\n      ...(config.readerConfig ?? {}),\n      source: config.readerConfig?.source ?? FeatureFlagEnvironment,\n    };\n    this.cachedRegistry = await this.refreshCachedRegistry(readerConfig, ...args);\n    const effectiveConfig: FeatureFlagServiceConfig = {\n      ...config,\n      reader: this.reader,\n      readerConfig,\n    };\n    return { config: effectiveConfig, client: this.reader };\n  }\n\n  private cloneRegistry(registry: FeatureFlagRegistry): FeatureFlagRegistry {\n    return Object.entries(registry).reduce((acc, [key, value]) => {\n      acc[key] =\n        value && typeof value === \"object\" && !Array.isArray(value)\n          ? ({ ...(value as FeatureFlagConfig) } as FeatureFlagConfig)\n          : value;\n      return acc;\n    }, {} as FeatureFlagRegistry);\n  }\n\n  private async refreshCachedRegistry(\n    options: FeatureFlagReaderInput = {},\n    ...args: any[]\n  ): Promise<FeatureFlagRegistry> {\n    const envRegistry = await this.reader.read({\n      ...options,\n      source: options.source ?? FeatureFlagEnvironment,\n    });\n    let persisted: FeatureFlag[] = [];\n    try {\n      persisted = await this.repo.select().execute(...args);\n    } catch {\n      persisted = [];\n    }\n\n    const registry = this.cloneRegistry(envRegistry);\n    for (const flag of persisted) {\n      registry[flag.key] = flag.enabled ? (flag.config ?? true) : false;\n    }\n    return registry;\n  }\n\n  private setCachedFlag(flag: FeatureFlag): void {\n    this.cachedRegistry[flag.key] = flag.enabled\n      ? (flag.config ?? true)\n      : false;\n  }\n\n  private getAccessRepository(): Repo<FeatureFlagAccess> {\n    return this.accessRepository ?? Repository.forModel(FeatureFlagAccess);\n  }\n\n  private assertInitialized(): void {\n    void this.reader;\n  }\n\n  private normalizeFeatureAccessInput(\n    input: FeatureFlagAccessInput\n  ): FeatureFlagAccessInput {\n    return {\n      ...input,\n      featureKey: normalizeFeatureName(input.featureKey),\n      subjectType: normalizeFeatureSubjectType(input.subjectType),\n      subjectKey: normalizeFeatureSubjectKey(input.subjectKey),\n    };\n  }\n\n  private buildAccessCondition(\n    query: FeatureFlagAccessQuery\n  ): Condition<FeatureFlagAccess> {\n    let condition = Condition.attr<FeatureFlagAccess>(\"subjectType\").eq(\n      normalizeFeatureSubjectType(query.subjectType)\n    );\n    condition = condition.and(\n      Condition.attr<FeatureFlagAccess>(\"subjectKey\").eq(\n        normalizeFeatureSubjectKey(query.subjectKey)\n      )\n    );\n    if (typeof query.enabled !== \"undefined\") {\n      condition = condition.and(\n        Condition.attr<FeatureFlagAccess>(\"enabled\").eq(query.enabled)\n      );\n    }\n    if (query.featureKeys && query.featureKeys.length > 0) {\n      condition = condition.and(\n        Condition.attr<FeatureFlagAccess>(\"featureKey\").in(\n          query.featureKeys.map(normalizeFeatureName)\n        )\n      );\n    }\n    return condition;\n  }\n\n  override async create(\n    model: FeatureFlag,\n    ...args: any[]\n  ): Promise<FeatureFlag> {\n    model.key = normalizeFeatureName(model.key);\n    model.enabled ??= true;\n    const created = await super.create(model, ...args);\n    this.setCachedFlag(created);\n    return created;\n  }\n\n  override async update(\n    model: FeatureFlag,\n    ...args: any[]\n  ): Promise<FeatureFlag> {\n    model.key = normalizeFeatureName(model.key);\n    model.enabled ??= true;\n    const updated = await super.update(model, ...args);\n    this.setCachedFlag(updated);\n    return updated;\n  }\n\n  override async findOneBy(\n    key: keyof FeatureFlag,\n    value: any,\n    ...args: any[]\n  ): Promise<FeatureFlag> {\n    const normalizedValue =\n      key === \"key\" && typeof value === \"string\"\n        ? normalizeFeatureName(value)\n        : value;\n    return this.repo.findOneBy(key, normalizedValue, ...args);\n  }\n\n  override async readAll(\n    keys: any[],\n    ...args: any[]\n  ): Promise<FeatureFlag[]> {\n    const result = await this.repo.readAll(keys, ...args);\n    for (const flag of result) this.setCachedFlag(flag);\n    return result;\n  }\n\n  async listEnabled(...args: any[]): Promise<FeatureFlag[]> {\n    return this.repo\n      .select()\n      .where(Condition.attr<FeatureFlag>(\"enabled\").eq(true))\n      .execute(...args);\n  }\n\n  async grantFeatureAccess(\n    input: FeatureFlagAccessInput,\n    ...args: any[]\n  ): Promise<FeatureFlagAccess> {\n    const normalized = this.normalizeFeatureAccessInput(input);\n    const existing = await this.findFeatureAccess(normalized, ...args).catch(\n      () => undefined\n    );\n    if (!existing) {\n      return this.getAccessRepository().create(\n        new FeatureFlagAccess(normalized),\n        ...args\n      );\n    }\n    return this.getAccessRepository().update(\n      Object.assign(existing, normalized),\n      ...args\n    );\n  }\n\n  async revokeFeatureAccess(\n    input: FeatureFlagAccessSubject & { featureKey: string },\n    ...args: any[]\n  ): Promise<FeatureFlagAccess | undefined> {\n    const existing = await this.findFeatureAccess(input, ...args).catch(\n      () => undefined\n    );\n    if (!existing) return undefined;\n    return this.getAccessRepository().delete(existing.id, ...args);\n  }\n\n  async findFeatureAccess(\n    query: FeatureFlagAccessQuery,\n    ...args: any[]\n  ): Promise<FeatureFlagAccess> {\n    const condition = this.buildAccessCondition(query);\n    const results = await this.getAccessRepository()\n      .select()\n      .where(condition)\n      .execute(...args);\n    const existing = results[0];\n    if (!existing) {\n      throw new NotFoundError(\n        `Feature access for ${normalizeFeatureSubjectType(query.subjectType)}:${normalizeFeatureSubjectKey(query.subjectKey)} not found`\n      );\n    }\n    return existing;\n  }\n\n  async listFeatureAccess(\n    query: FeatureFlagAccessQuery,\n    ...args: any[]\n  ): Promise<FeatureFlagAccess[]> {\n    return this.getAccessRepository()\n      .select()\n      .where(this.buildAccessCondition(query))\n      .execute(...args);\n  }\n\n  async resolveFeatureFlagsForSubject(\n    subject: FeatureFlagAccessSubject,\n    ...args: any[]\n  ): Promise<FeatureFlagRegistry> {\n    this.assertInitialized();\n    const access = await this.listFeatureAccess(\n      {\n        ...subject,\n        enabled: true,\n      },\n      ...args\n    );\n    const featureKeys = [...new Set(access.map((item) => item.featureKey))];\n    if (featureKeys.length === 0) return {};\n\n    const condition = Condition.attr<FeatureFlag>(\"enabled\").eq(true).and(\n      Condition.attr<FeatureFlag>(\"key\").in(\n        featureKeys.map(normalizeFeatureName)\n      )\n    );\n\n    const enabledFlags = await this.repo.select().where(condition).execute(...args);\n    return enabledFlags.reduce((registry, flag) => {\n      registry[flag.key] = flag.config ?? true;\n      return registry;\n    }, {} as FeatureFlagRegistry);\n  }\n\n  async isEnabledForSubject(\n    key: string,\n    subject: FeatureFlagAccessSubject,\n    ...args: any[]\n  ): Promise<boolean> {\n    const registry = await this.resolveFeatureFlagsForSubject(subject, ...args);\n    return isFeatureFlagEnabledByName(registry, key);\n  }\n\n  isEnabled(key: string): boolean {\n    this.assertInitialized();\n    const normalizedKey = normalizeFeatureName(key);\n    return isFeatureFlagEnabledByName(this.cachedRegistry, normalizedKey);\n  }\n\n  async resolveFeatureFlags(): Promise<FeatureFlagRegistry> {\n    this.assertInitialized();\n    return this.cloneRegistry(this.cachedRegistry);\n  }\n\n  async syncFromEnvironment(\n    options: FeatureFlagReaderInput = {},\n    ...args: any[]\n  ): Promise<FeatureFlag[]> {\n    this.assertInitialized();\n    const registry = await this.reader.read({\n      ...options,\n      source: options.source ?? FeatureFlagEnvironment,\n    });\n    const results: FeatureFlag[] = [];\n    for (const [key, value] of Object.entries(registry)) {\n      const config =\n        value && typeof value === \"object\" && !Array.isArray(value)\n          ? (value as FeatureFlagConfig)\n          : { enabled: Boolean(value) };\n      const { enabled: _ignoredEnabled, ...restConfig } = config;\n      const normalizedKey = normalizeFeatureName(key);\n      const existing = await this.findOneBy(\n        \"key\",\n        normalizedKey,\n        ...args\n      ).catch(() => undefined);\n      const model = existing\n        ? Object.assign(existing, {\n            enabled: isFeatureFlagEnabled(value),\n            description: restConfig.description ?? existing.description,\n            scope: restConfig.scope ?? existing.scope,\n            metadata: restConfig.metadata ?? existing.metadata,\n            config: {\n              ...restConfig,\n              enabled: isFeatureFlagEnabled(value),\n            },\n          })\n        : new FeatureFlag({\n            key: normalizedKey,\n            enabled: isFeatureFlagEnabled(value),\n            description: restConfig.description,\n            scope: restConfig.scope,\n            metadata: restConfig.metadata,\n            config: {\n              ...restConfig,\n              enabled: isFeatureFlagEnabled(value),\n            },\n          });\n      results.push(existing ? await this.update(model, ...args) : await this.create(model, ...args));\n    }\n    this.cachedRegistry = await this.refreshCachedRegistry(\n      {\n        ...options,\n        source: options.source ?? FeatureFlagEnvironment,\n      },\n      ...args\n    );\n    return results;\n  }\n}\n"]}

package/lib/esm/feature-flags/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZmVhdHVyZS1mbGFncy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgRmVhdHVyZUZsYWdNYXRjaE1vZGUgPSBcImFueVwiIHwgXCJhbGxcIjtcbmV4cG9ydCB0eXBlIEZlYXR1cmVGbGFnQWNjZXNzU3ViamVjdFR5cGUgPVxuICB8IFwidXNlclwiXG4gIHwgXCJhY2NvdW50XCJcbiAgfCBcIm5hbWVzcGFjZVwiXG4gIHwgXCJtb2RlbFwiXG4gIHwgXCJyb3V0ZVwiXG4gIHwgXCJ1aVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZlYXR1cmVGbGFnUnVsZSB7XG4gIGZlYXR1cmVzOiBzdHJpbmdbXTtcbiAgbWF0Y2g/OiBGZWF0dXJlRmxhZ01hdGNoTW9kZTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGZWF0dXJlRmxhZ0NvbmZpZyB7XG4gIGVuYWJsZWQ/OiBib29sZWFuO1xuICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgbWV0YWRhdGE/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgc2NvcGU/OiBzdHJpbmc7XG4gIHRhcmdldHM/OiBzdHJpbmdbXTtcbiAgW2tleTogc3RyaW5nXTogdW5rbm93bjtcbn1cblxuZXhwb3J0IHR5cGUgRmVhdHVyZUZsYWdWYWx1ZSA9IGJvb2xlYW4gfCBGZWF0dXJlRmxhZ0NvbmZpZztcblxuZXhwb3J0IHR5cGUgRmVhdHVyZUZsYWdSZWdpc3RyeSA9IFJlY29yZDxzdHJpbmcsIEZlYXR1cmVGbGFnVmFsdWU+O1xuXG5leHBvcnQgaW50ZXJmYWNlIEZlYXR1cmVGbGFnRW52aXJvbm1lbnRTaGFwZSB7XG4gIGZlYXR1cmVGbGFnPzogRmVhdHVyZUZsYWdSZWdpc3RyeTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGZWF0dXJlRmxhZ0FjY2Vzc1N1YmplY3Qge1xuICBzdWJqZWN0VHlwZTogRmVhdHVyZUZsYWdBY2Nlc3NTdWJqZWN0VHlwZTtcbiAgc3ViamVjdEtleTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEZlYXR1cmVGbGFnQWNjZXNzSW5wdXQgZXh0ZW5kcyBGZWF0dXJlRmxhZ0FjY2Vzc1N1YmplY3Qge1xuICBmZWF0dXJlS2V5OiBzdHJpbmc7XG4gIGVuYWJsZWQ/OiBib29sZWFuO1xuICBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEZlYXR1cmVGbGFnQWNjZXNzUXVlcnkgZXh0ZW5kcyBGZWF0dXJlRmxhZ0FjY2Vzc1N1YmplY3Qge1xuICBmZWF0dXJlS2V5cz86IHN0cmluZ1tdO1xuICBlbmFibGVkPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGZWF0dXJlRmxhZ1JlYWRlcklucHV0IHtcbiAgc291cmNlPzogRmVhdHVyZUZsYWdFbnZpcm9ubWVudFNoYXBlIHwgdW5rbm93bjtcbiAgW2tleTogc3RyaW5nXTogdW5rbm93bjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGZWF0dXJlRmxhZ1JlYWRlckNvbmZpZyB7XG4gIHJlYWRlckNvbmZpZz86IEZlYXR1cmVGbGFnUmVhZGVySW5wdXQ7XG59XG4iXX0=