@velajs/feature-flags 0.1.0 → 0.1.1

package/dist/feature-flags.tokens.js

@@ -1,10 +0,0 @@
-import { moduleToken } from "@velajs/vela";
-/**
- * Injection tokens for the feature-flags module. Named on the
- * `vela:feature-flags:<thing>` convention so identity is stable across
- * refactors and consumers can `@Inject(FEATURE_FLAG_TOKENS.Service)`.
- */ export const FEATURE_FLAG_TOKENS = {
-    /** The resolved {@link FeatureFlagsOptions} (module options token). */ Options: moduleToken('vela:feature-flags:options'),
-    /** The injectable {@link FeatureFlagsService}. */ Service: moduleToken('vela:feature-flags:service'),
-    /** The {@link FeatureFlagDriverRegistry} built from the options' drivers. */ DriverRegistry: moduleToken('vela:feature-flags:driver-registry')
-};

package/dist/feature-flags.types.d.ts

@@ -1,71 +0,0 @@
-import type { RequestContext } from '@velajs/vela';
-import type { FeatureFlagDriver } from './drivers/driver';
-/**
- * A value a feature flag can resolve to. Mirrors the four evaluation methods
- * on {@link FeatureFlagDriver}.
- */
-export type FlagValue = boolean | string | number | object;
-/**
- * A free-form evaluation context handed to a driver (for targeting: user id,
- * plan, country, …). Drivers that don't do targeting ignore it.
- */
-export type FlagContext = Record<string, unknown>;
-/**
- * Augment this interface to get typed flag keys on the service and the
- * `@FeatureFlag()` decorator.
- *
- * @example
- * ```ts
- * declare module '@velajs/feature-flags' {
- *   interface FeatureFlagRegistry {
- *     'new-checkout': boolean;
- *     'checkout-flow': string;
- *   }
- * }
- * ```
- */
-export interface FeatureFlagRegistry {
-}
-/**
- * A flag key. Narrows to the declared {@link FeatureFlagRegistry} keys when the
- * app augments it; falls back to `string` otherwise.
- */
-export type FlagKey = keyof FeatureFlagRegistry extends never ? string : keyof FeatureFlagRegistry & string;
-/**
- * A declared set of flags and their default values.
- *
- * Drivers have no enumeration API, so the flags you intend to evaluate as a
- * batch (via {@link FeatureFlagsService.all}) must be declared once here. Each
- * default also doubles as the type hint used to pick the evaluation method.
- */
-export type FlagManifest = Record<string, FlagValue>;
-/** Why an evaluation returned the value it did. */
-export type FlagEvaluationReason = 'STATIC' | 'DEFAULT' | 'ERROR';
-/** A flag value plus the metadata the service synthesizes around a driver read. */
-export interface FlagEvaluationDetails<T extends FlagValue = FlagValue> {
-    flagKey: string;
-    value: T;
-    reason: FlagEvaluationReason;
-    errorMessage?: string;
-}
-/**
- * Feature-flags module configuration.
- */
-export interface FeatureFlagsOptions {
-    /**
-     * The drivers this app can evaluate against. When omitted, a single
-     * in-memory {@link MemoryFlagDriver} named `"memory"` is used (all flags
-     * resolve to their declared defaults).
-     */
-    drivers?: FeatureFlagDriver[];
-    /** Name of the driver the injected service targets. Defaults to `drivers[0].name`. */
-    default?: string;
-    /** Declared flags + defaults. Powers manifest defaults and {@link FeatureFlagsService.all}. */
-    manifest?: FlagManifest;
-    /**
-     * Resolves a per-request evaluation context (for example `{ userId }`) merged
-     * into every evaluation. Per-call context passed to a method overrides these.
-     * Receives the current request context; skipped outside request scope.
-     */
-    context?: (ctx: RequestContext) => FlagContext | Promise<FlagContext>;
-}

package/dist/feature-flags.types.js

@@ -1,3 +0,0 @@
-/**
- * Feature-flags module configuration.
- */ export { };

package/dist/guards/feature-flag.guard.d.ts

@@ -1,24 +0,0 @@
-import { type CanActivate, type ExecutionContext } from '@velajs/vela';
-import type { FeatureFlagsService } from '../feature-flags.service';
-/**
- * Route gate for `@FeatureFlag()`. Reads the handler/controller metadata, then
- * `getBooleanValue(key)`; when the flag is off it throws `NotFoundException`
- * (the route appears hidden) or `ForbiddenException` per the decorator option.
- * Handlers with no `@FeatureFlag()` metadata pass through untouched, so the
- * guard is safe to register app-wide (`FeatureFlagsModule.forRoot({ isGlobal:
- * true })`) or per-route via `@UseGuards(FeatureFlagGuard)`.
- *
- * It does NOT inject `REQUEST_CONTEXT` — that would make the guard request-
- * scoped and break lazy-module materialization (which constructs every provider
- * once, at first use, possibly outside a request). Instead it reads the request
- * context off the per-request child container carried on the Hono context, so
- * the module's `context` resolver still runs for the gate decision.
- */
-export declare class FeatureFlagGuard implements CanActivate {
-    private readonly flags;
-    private readonly reflector;
-    constructor(flags: FeatureFlagsService);
-    canActivate(context: ExecutionContext): Promise<boolean>;
-    /** The current request context, via the child container on the Hono context. */
-    private requestContext;
-}

package/dist/guards/feature-flag.guard.js

@@ -1,52 +0,0 @@
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { ForbiddenException, Inject, Injectable, NotFoundException, REQUEST_CONTEXT, Reflector } from "@velajs/vela";
-import { FEATURE_FLAG_METADATA } from "../decorators/feature-flag.decorator.js";
-import { FEATURE_FLAG_TOKENS } from "../feature-flags.tokens.js";
-export class FeatureFlagGuard {
-    flags;
-    reflector = new Reflector();
-    constructor(flags){
-        this.flags = flags;
-    }
-    async canActivate(context) {
-        const meta = this.reflector.getAllAndOverride(FEATURE_FLAG_METADATA, context);
-        if (!meta) return true;
-        const requestContext = this.requestContext(context);
-        const flags = requestContext ? this.flags.forRequest(requestContext) : this.flags;
-        const enabled = await flags.getBooleanValue(meta.key);
-        if (enabled) return true;
-        if (meta.onDisabled === 'forbidden') {
-            throw new ForbiddenException(`Feature "${meta.key}" is not enabled.`);
-        }
-        throw new NotFoundException();
-    }
-    /** The current request context, via the child container on the Hono context. */ requestContext(context) {
-        try {
-            const container = context.getContext().get('container');
-            return container?.resolve(REQUEST_CONTEXT);
-        } catch  {
-            return undefined;
-        }
-    }
-}
-FeatureFlagGuard = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(FEATURE_FLAG_TOKENS.Service)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof FeatureFlagsService === "undefined" ? Object : FeatureFlagsService
-    ])
-], FeatureFlagGuard);