@quanticjs/feature-flags 2.0.0

package/dist/FeatureFlagBehavior.d.ts

@@ -0,0 +1,10 @@
+import { Unleash } from 'unleash-client';
+import { Result, PipelineBehavior, PipelineScope } from '@quanticjs/core';
+export declare class FeatureFlagBehavior implements PipelineBehavior {
+    private readonly unleash?;
+    readonly order: 30;
+    readonly scope: PipelineScope;
+    private readonly logger;
+    constructor(unleash?: Unleash | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+}

package/dist/FeatureFlagBehavior.js

@@ -0,0 +1,59 @@
+"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); }
+};
+var FeatureFlagBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const unleash_client_1 = require("unleash-client");
+const core_1 = require("@quanticjs/core");
+let FeatureFlagBehavior = FeatureFlagBehavior_1 = class FeatureFlagBehavior {
+    unleash;
+    order = core_1.BehaviorOrder.FEATURE_FLAG;
+    scope = 'both';
+    logger = new common_1.Logger(FeatureFlagBehavior_1.name);
+    constructor(unleash) {
+        this.unleash = unleash;
+    }
+    async execute(command, next) {
+        const metadata = (0, core_1.getFeatureFlagMetadata)(command.constructor);
+        if (!metadata) {
+            return next();
+        }
+        if (!this.unleash) {
+            this.logger.debug('Unleash not configured, skipping feature flag check');
+            return next();
+        }
+        const { flagName, fallback, defaultValue } = metadata;
+        const isEnabled = this.unleash.isEnabled(flagName);
+        if (isEnabled) {
+            return next();
+        }
+        this.logger.warn(`Feature flag "${flagName}" is disabled, applying fallback: ${fallback}`);
+        switch (fallback) {
+            case 'skip':
+                return core_1.Result.success(undefined);
+            case 'default':
+                return core_1.Result.success(defaultValue);
+            case 'throw':
+            default:
+                return core_1.Result.failure(core_1.ErrorType.Forbidden, `Feature "${flagName}" is currently disabled`);
+        }
+    }
+};
+exports.FeatureFlagBehavior = FeatureFlagBehavior;
+exports.FeatureFlagBehavior = FeatureFlagBehavior = FeatureFlagBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [unleash_client_1.Unleash])
+], FeatureFlagBehavior);

package/dist/QuanticFeatureFlagsModule.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { UnleashModuleOptions } from './unleash.module';
+export declare class QuanticFeatureFlagsModule {
+    static forRoot(options?: UnleashModuleOptions): DynamicModule;
+}

package/dist/QuanticFeatureFlagsModule.js

@@ -0,0 +1,34 @@
+"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 QuanticFeatureFlagsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticFeatureFlagsModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+const unleash_module_1 = require("./unleash.module");
+const FeatureFlagBehavior_1 = require("./FeatureFlagBehavior");
+let QuanticFeatureFlagsModule = QuanticFeatureFlagsModule_1 = class QuanticFeatureFlagsModule {
+    static forRoot(options) {
+        return {
+            module: QuanticFeatureFlagsModule_1,
+            imports: [unleash_module_1.UnleashModule.forRoot(options)],
+            providers: [
+                { provide: core_1.PIPELINE_BEHAVIOR, useExisting: FeatureFlagBehavior_1.FeatureFlagBehavior, multi: true },
+            ],
+            exports: [
+                unleash_module_1.UnleashModule,
+                FeatureFlagBehavior_1.FeatureFlagBehavior,
+            ],
+        };
+    }
+};
+exports.QuanticFeatureFlagsModule = QuanticFeatureFlagsModule;
+exports.QuanticFeatureFlagsModule = QuanticFeatureFlagsModule = QuanticFeatureFlagsModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], QuanticFeatureFlagsModule);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { FeatureFlagBehavior } from './FeatureFlagBehavior';
+export { UnleashModule } from './unleash.module';
+export type { UnleashModuleOptions } from './unleash.module';
+export { QuanticFeatureFlagsModule } from './QuanticFeatureFlagsModule';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticFeatureFlagsModule = exports.UnleashModule = exports.FeatureFlagBehavior = void 0;
+var FeatureFlagBehavior_1 = require("./FeatureFlagBehavior");
+Object.defineProperty(exports, "FeatureFlagBehavior", { enumerable: true, get: function () { return FeatureFlagBehavior_1.FeatureFlagBehavior; } });
+var unleash_module_1 = require("./unleash.module");
+Object.defineProperty(exports, "UnleashModule", { enumerable: true, get: function () { return unleash_module_1.UnleashModule; } });
+var QuanticFeatureFlagsModule_1 = require("./QuanticFeatureFlagsModule");
+Object.defineProperty(exports, "QuanticFeatureFlagsModule", { enumerable: true, get: function () { return QuanticFeatureFlagsModule_1.QuanticFeatureFlagsModule; } });

package/dist/unleash.module.d.ts

@@ -0,0 +1,9 @@
+import { DynamicModule } from '@nestjs/common';
+export interface UnleashModuleOptions {
+    url?: string;
+    appName?: string;
+    customHeaders?: Record<string, string>;
+}
+export declare class UnleashModule {
+    static forRoot(options?: UnleashModuleOptions): DynamicModule;
+}

package/dist/unleash.module.js

@@ -0,0 +1,47 @@
+"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 UnleashModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnleashModule = void 0;
+const common_1 = require("@nestjs/common");
+const unleash_client_1 = require("unleash-client");
+const FeatureFlagBehavior_1 = require("./FeatureFlagBehavior");
+let UnleashModule = UnleashModule_1 = class UnleashModule {
+    static forRoot(options) {
+        const unleashProvider = {
+            provide: unleash_client_1.Unleash,
+            useFactory: () => {
+                const logger = new common_1.Logger('UnleashModule');
+                const url = options?.url || process.env['UNLEASH_URL'] || 'http://localhost:4242/api';
+                const appName = options?.appName || process.env['UNLEASH_APP_NAME'] || 'arex';
+                const token = options?.customHeaders?.['Authorization'] ||
+                    process.env['UNLEASH_API_TOKEN'] ||
+                    '*:*.unleash-insecure-api-token';
+                logger.log(`Connecting to Unleash at ${url}`);
+                return (0, unleash_client_1.initialize)({
+                    url,
+                    appName,
+                    customHeaders: {
+                        Authorization: token,
+                    },
+                    refreshInterval: 10000,
+                });
+            },
+        };
+        return {
+            module: UnleashModule_1,
+            providers: [unleashProvider, FeatureFlagBehavior_1.FeatureFlagBehavior],
+            exports: [unleash_client_1.Unleash, FeatureFlagBehavior_1.FeatureFlagBehavior],
+        };
+    }
+};
+exports.UnleashModule = UnleashModule;
+exports.UnleashModule = UnleashModule = UnleashModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], UnleashModule);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@quanticjs/feature-flags",
+  "version": "2.0.0",
+  "description": "Feature flag integration for quanticjs — Unleash-backed pipeline behavior",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@quanticjs/core": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "unleash-client": "^6.0.0"
+  }
+}