@nestarc/feature-flag 0.1.0 → 0.3.0

package/README.md

@@ -1,16 +1,25 @@
 # @nestarc/feature-flag
 
-DB-backed feature flags for NestJS + Prisma + PostgreSQL -- tenant-aware overrides, percentage rollouts, and zero external dependencies.
+[![npm version](https://img.shields.io/npm/v/@nestarc/feature-flag.svg)](https://www.npmjs.com/package/@nestarc/feature-flag)
+[![npm downloads](https://img.shields.io/npm/dm/@nestarc/feature-flag.svg)](https://www.npmjs.com/package/@nestarc/feature-flag)
+[![CI](https://github.com/nestarc/nestjs-feature-flag/actions/workflows/ci.yml/badge.svg)](https://github.com/nestarc/nestjs-feature-flag/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Docs](https://img.shields.io/badge/docs-nestarc.dev-blue.svg)](https://nestarc.dev/packages/feature-flag/)
+
+DB-backed feature flags for NestJS + Prisma + PostgreSQL -- attribute-targeted overrides, percentage rollouts, and zero external dependencies.
 
 ## Features
 
 - **Database-backed** -- flags stored in PostgreSQL via Prisma, no external service required
-- **Tenant / user / environment overrides** -- granular control per tenant, user, or deployment environment
+- **Attribute-targeted overrides** -- exact-match targeting for tenants, users, environments, plans, regions, or custom dimensions
 - **Percentage rollouts** -- deterministic hashing (murmurhash3) for consistent per-user bucketing
 - **Guard decorator** -- `@FeatureFlag()` automatically gates routes and controllers
 - **Bypass decorator** -- `@BypassFeatureFlag()` exempts health checks and public endpoints
 - **Programmatic evaluation** -- `isEnabled()` and `evaluateAll()` for service-layer logic
-- **Built-in caching** -- configurable TTL with manual invalidation
+- **Built-in caching** -- configurable TTL with manual invalidation; Redis Pub/Sub for multi-instance
+- **Pluggable persistence** -- `FeatureFlagRepository` interface for custom backends (Prisma default)
+- **Pluggable tenancy** -- `TenantContextProvider` interface for custom tenant resolution
+- **Admin REST API** -- opt-in `FeatureFlagAdminModule` with guard injection and proper error responses
 - **Event system** -- optional integration with `@nestjs/event-emitter` for audit and observability
 - **Testing utilities** -- drop-in `TestFeatureFlagModule` for unit and integration tests
 
@@ -23,7 +32,7 @@ npm install @nestarc/feature-flag
 ### Peer dependencies
 
 ```bash
-npm install @nestjs/common @nestjs/core @prisma/client rxjs reflect-metadata
+npm install @nestjs/common @nestjs/core @prisma/client class-transformer class-validator rxjs reflect-metadata
 ```
 
 ### Optional
@@ -31,8 +40,35 @@ npm install @nestjs/common @nestjs/core @prisma/client rxjs reflect-metadata
 ```bash
 # Required only if you enable emitEvents
 npm install @nestjs/event-emitter
+
+# Required only if you use RedisCacheAdapter
+npm install ioredis
 ```
 
+## Redis Cache (Multi-Instance)
+
+For production deployments with multiple instances, use `RedisCacheAdapter` for shared caching and real-time invalidation via Redis Pub/Sub:
+
+```typescript
+import { FeatureFlagModule, RedisCacheAdapter } from '@nestarc/feature-flag';
+import { Redis } from 'ioredis';
+
+const redisClient = new Redis({ host: 'localhost', port: 6379 });
+
+FeatureFlagModule.forRoot({
+  environment: 'production',
+  prisma,
+  cacheAdapter: new RedisCacheAdapter({
+    client: redisClient,
+    // subscriber is auto-created via client.duplicate()
+    // keyPrefix: 'feature-flag:',   // default
+    // channel: 'feature-flag:invalidate',  // default
+  }),
+})
+```
+
+When a flag is updated on any instance, all other instances are notified via Pub/Sub and invalidate their cache immediately — eliminating the stale-cache window.
+
 ## Prisma Schema
 
 Add the following models to your `schema.prisma`:
@@ -55,14 +91,13 @@ model FeatureFlag {
 }
 
 model FeatureFlagOverride {
-  id          String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
-  flagId      String   @map("flag_id") @db.Uuid
-  tenantId    String?  @map("tenant_id")
-  userId      String?  @map("user_id")
-  environment String?
-  enabled     Boolean
-  createdAt   DateTime @default(now()) @map("created_at") @db.Timestamptz()
-  updatedAt   DateTime @updatedAt @map("updated_at") @db.Timestamptz()
+  id         String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  flagId     String   @map("flag_id") @db.Uuid
+  attributes Json
+  priority   Int      @default(0)
+  enabled    Boolean
+  createdAt  DateTime @default(now()) @map("created_at") @db.Timestamptz()
+  updatedAt  DateTime @updatedAt @map("updated_at") @db.Timestamptz()
 
   flag FeatureFlag @relation(fields: [flagId], references: [id], onDelete: Cascade)
 
@@ -71,57 +106,48 @@ model FeatureFlagOverride {
 }
 ```
 
-### Partial unique indexes for overrides
-
-PostgreSQL treats `NULL != NULL` in standard unique constraints, which means a simple `UNIQUE(flag_id, tenant_id, user_id, environment)` would allow duplicate rows when any nullable column is `NULL`. To enforce true uniqueness across all combinations, apply the following migration that creates one partial index per NULL/NOT-NULL pattern:
+The v0.3.0 migration uses an `{}` default only while backfilling legacy rows, then drops that default. It also creates a unique index on `(flag_id, attributes)` and a check constraint requiring override attributes to be a non-empty JSON object. If you copy this schema into a greenfield app instead of running the included migrations, add an equivalent raw SQL migration because Prisma schema cannot express these PostgreSQL constraints:
 
 ```sql
--- Drop the old unique constraint that does not handle NULLs correctly
-ALTER TABLE feature_flag_overrides
-  DROP CONSTRAINT IF EXISTS uq_override_context;
-
--- Global override (all nullable columns NULL)
-CREATE UNIQUE INDEX uq_override_000
-  ON feature_flag_overrides (flag_id)
-  WHERE tenant_id IS NULL AND user_id IS NULL AND environment IS NULL;
-
--- Only environment is NOT NULL
-CREATE UNIQUE INDEX uq_override_001
-  ON feature_flag_overrides (flag_id, environment)
-  WHERE tenant_id IS NULL AND user_id IS NULL AND environment IS NOT NULL;
-
--- Only user_id is NOT NULL
-CREATE UNIQUE INDEX uq_override_010
-  ON feature_flag_overrides (flag_id, user_id)
-  WHERE tenant_id IS NULL AND user_id IS NOT NULL AND environment IS NULL;
-
--- user_id + environment
-CREATE UNIQUE INDEX uq_override_011
-  ON feature_flag_overrides (flag_id, user_id, environment)
-  WHERE tenant_id IS NULL AND user_id IS NOT NULL AND environment IS NOT NULL;
-
--- Only tenant_id is NOT NULL
-CREATE UNIQUE INDEX uq_override_100
-  ON feature_flag_overrides (flag_id, tenant_id)
-  WHERE tenant_id IS NOT NULL AND user_id IS NULL AND environment IS NULL;
-
--- tenant_id + environment
-CREATE UNIQUE INDEX uq_override_101
-  ON feature_flag_overrides (flag_id, tenant_id, environment)
-  WHERE tenant_id IS NOT NULL AND user_id IS NULL AND environment IS NOT NULL;
-
--- tenant_id + user_id
-CREATE UNIQUE INDEX uq_override_110
-  ON feature_flag_overrides (flag_id, tenant_id, user_id)
-  WHERE tenant_id IS NOT NULL AND user_id IS NOT NULL AND environment IS NULL;
-
--- All three NOT NULL
-CREATE UNIQUE INDEX uq_override_111
-  ON feature_flag_overrides (flag_id, tenant_id, user_id, environment)
-  WHERE tenant_id IS NOT NULL AND user_id IS NOT NULL AND environment IS NOT NULL;
+CREATE UNIQUE INDEX "uq_feature_flag_override_attributes"
+  ON "feature_flag_overrides"("flag_id", "attributes");
+
+ALTER TABLE "feature_flag_overrides"
+  ADD CONSTRAINT "chk_feature_flag_override_attributes_non_empty"
+  CHECK (jsonb_typeof("attributes") = 'object' AND "attributes" <> '{}'::jsonb);
+```
+
+### Migration from 0.2.0 to 0.3.0
+
+v0.3.0 changes override storage from fixed `tenant_id`, `user_id`, and `environment` columns to an `attributes` `jsonb` object plus `priority`.
+
+Run your Prisma migrations during deployment:
+
+```bash
+npx prisma migrate deploy
+```
+
+The migration maps legacy override columns into attributes:
+
+| v0.2.0 column | v0.3.0 attribute |
+| ------------- | ---------------- |
+| `tenant_id` | `attributes.tenantId` |
+| `user_id` | `attributes.userId` |
+| `environment` | `attributes.environment` |
+
+Rows with all three legacy columns set to `NULL` are deleted because empty override attributes are not valid in v0.3.0. If multiple legacy rows backfill to the same `(flag_id, attributes)`, the migration keeps the row with the latest `updated_at`, then latest `created_at`, then highest `id`, and deletes the other duplicates before creating the unique index.
+
+Legacy Admin API bodies are rejected:
+
+```json
+{ "tenantId": "tenant-1", "enabled": true }
 ```
 
-This SQL is included in the initial migration at `prisma/migrations/20260405000000_init/migration.sql`.
+Use an `attributes` object instead:
+
+```json
+{ "attributes": { "tenantId": "tenant-1" }, "enabled": true }
+```
 
 ## Module Registration
 
@@ -322,41 +348,64 @@ Passing `null` explicitly clears that dimension, suppressing any ambient value f
 const globalResult = await this.flags.isEnabled('MY_FLAG', { userId: null });
 ```
 
-## Overrides
+## Attribute Targeting
 
-Set context-specific overrides that take precedence over the global flag value:
+Overrides match exact attributes. Every key/value in an override's `attributes` object must exist in the evaluation context attributes for the override to apply.
 
 ```typescript
-// Enable for a specific tenant
-await this.flags.setOverride('MY_FLAG', {
+const enabled = await this.flags.isEnabled('NEW_CHECKOUT', {
+  userId: 'user-123',
   tenantId: 'tenant-1',
-  enabled: true,
+  environment: 'production',
+  attributes: {
+    plan: 'pro',
+    country: 'KR',
+  },
 });
+```
 
-// Disable for a specific user
-await this.flags.setOverride('MY_FLAG', {
-  userId: 'user-42',
-  enabled: false,
-});
+Top-level `userId`, `tenantId`, and `environment` are merged into targeting attributes. If the same key also appears in `attributes`, the top-level value wins.
 
-// Enable only in staging
-await this.flags.setOverride('MY_FLAG', {
-  environment: 'staging',
-  enabled: true,
-});
+When multiple overrides match, the evaluator chooses the winner by:
 
-// Combine dimensions
-await this.flags.setOverride('MY_FLAG', {
-  tenantId: 'tenant-1',
-  userId: 'user-42',
-  environment: 'production',
+1. More attributes
+2. Higher `priority`
+3. Earlier `createdAt`
+4. Lower `id`
+
+## Overrides
+
+Set attribute-based overrides that take precedence over the global flag value:
+
+```typescript
+await flags.setOverride('NEW_CHECKOUT', {
+  attributes: {
+    tenantId: 'tenant-1',
+    plan: 'pro',
+    country: 'KR',
+  },
   enabled: true,
+  priority: 10,
 });
 ```
 
+REST Admin API body:
+
+```json
+{
+  "attributes": {
+    "tenantId": "tenant-1",
+    "plan": "pro",
+    "country": "KR"
+  },
+  "enabled": true,
+  "priority": 10
+}
+```
+
 ## Events
 
-Enable event emission to observe flag lifecycle changes. Requires `@nestjs/event-emitter` as an optional peer dependency.
+Enable event emission to observe flag lifecycle changes. Requires installing `@nestjs/event-emitter`.
 
 **Important:** You must import `EventEmitterModule.forRoot()` in your app module. The feature-flag module reuses the same `EventEmitter2` singleton that NestJS manages, so `@OnEvent()` listeners work out of the box.
 
@@ -438,20 +487,24 @@ describe('DashboardController', () => {
 });
 ```
 
-`TestFeatureFlagModule.register()` provides a global mock of `FeatureFlagService` where `isEnabled(key)` returns the boolean you specified (defaulting to `false` for unregistered keys) and `evaluateAll()` returns the full map.
+`TestFeatureFlagModule.register()` provides a global mock of `FeatureFlagService`:
+- `isEnabled(key)` returns the boolean you specified (defaulting to `false` for unregistered keys)
+- `evaluateAll()` returns the full flag map
+- `create()`, `update()`, `archive()`, `findByKey()`, `findAll()` return full `FeatureFlagWithOverrides` stub objects
+- `findByKey()` throws `NotFoundException` for unknown keys
+
+This is a **stateless boolean stub** -- write operations do not persist state across calls. For stateful test doubles, use your own mock implementation.
 
 ## Evaluation Priority
 
-When `isEnabled()` is called, flags are evaluated through a 6-layer cascade. The first matching layer wins:
+When `isEnabled()` is called, flags are evaluated through the current cascade. The first matching layer wins:
 
 | Priority | Layer                  | Description                                                        |
 | -------- | ---------------------- | ------------------------------------------------------------------ |
 | 1        | **Archived**           | If the flag has `archivedAt` set, evaluation always returns `false` |
-| 2        | **User override**      | Override matching the current `userId` (most specific)              |
-| 3        | **Tenant override**    | Override matching the current `tenantId`                            |
-| 4        | **Environment override**| Override matching the current `environment`                        |
-| 5        | **Percentage rollout** | Deterministic hash of `flagKey + userId` (or `tenantId`) mod 100   |
-| 6        | **Global default**     | The flag's `enabled` field                                         |
+| 2        | **Attribute override** | Best override whose attributes are all present in the evaluation context |
+| 3        | **Percentage rollout** | Deterministic hash of `flagKey + userId` (or `tenantId`) mod 100   |
+| 4        | **Global default**     | The flag's `enabled` field                                         |
 
 Percentage rollout uses murmurhash3 for deterministic bucketing: the same user always gets the same result for a given flag, ensuring a consistent experience across requests.
 
@@ -466,6 +519,7 @@ Percentage rollout uses murmurhash3 for deterministic bucketing: the same user a
 | `userIdExtractor`   | `(req: Request) => string \| null`| `undefined`| Extracts user ID from the incoming request                     |
 | `defaultOnMissing`  | `boolean`                         | `false`   | Value returned when a flag key does not exist in the database   |
 | `emitEvents`        | `boolean`                         | `false`   | Emit lifecycle events via `@nestjs/event-emitter`               |
+| `cacheAdapter`      | `CacheAdapter`                    | `MemoryCacheAdapter` | Pluggable cache backend (e.g. `RedisCacheAdapter`)  |
 
 ### FeatureFlagModuleRootOptions
 
@@ -504,6 +558,117 @@ const allFlags = await this.flags.findAll();
 this.flags.invalidateCache();
 ```
 
+## Admin REST API
+
+`FeatureFlagAdminModule` provides a REST API for managing flags. It requires a guard — the module won't register without one:
+
+```typescript
+import { FeatureFlagAdminModule } from '@nestarc/feature-flag';
+import { AdminAuthGuard } from './guards/admin-auth.guard';
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRoot({ ... }),
+    FeatureFlagAdminModule.register({
+      guard: AdminAuthGuard,
+      // path: 'feature-flags',  // default
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Endpoints
+
+| Method | Route | Description | Error Responses |
+|--------|-------|-------------|-----------------|
+| POST | `/feature-flags` | Create a flag | 409 duplicate key, 400 invalid percentage |
+| GET | `/feature-flags` | List all flags | |
+| GET | `/feature-flags/:key` | Get a single flag | 404 not found |
+| PATCH | `/feature-flags/:key` | Update a flag | 404 not found, 400 invalid percentage |
+| DELETE | `/feature-flags/:key` | Archive a flag | 404 not found |
+| POST | `/feature-flags/:key/overrides` | Set an override | 404 flag not found |
+| DELETE | `/feature-flags/:key/overrides` | Remove an override | 404 flag not found |
+
+Percentage values must be between 0 and 100 (inclusive). Invalid values return 400 Bad Request.
+
+## Custom Persistence (Advanced)
+
+The default `PrismaFeatureFlagRepository` can be replaced with any implementation of `FeatureFlagRepository`:
+
+```typescript
+import {
+  FeatureFlagModule,
+  FEATURE_FLAG_REPOSITORY,
+  FeatureFlagRepository,
+} from '@nestarc/feature-flag';
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRoot({
+      environment: 'production',
+      prisma, // still required for module init, but unused if you override the repository
+    }),
+  ],
+  providers: [
+    {
+      provide: FEATURE_FLAG_REPOSITORY,
+      useClass: MyCustomRepository, // implements FeatureFlagRepository
+    },
+  ],
+})
+export class AppModule {}
+```
+
+## Custom Tenant Resolution (Advanced)
+
+Override the default `@nestarc/tenancy` integration with your own `TenantContextProvider`:
+
+```typescript
+import {
+  FeatureFlagModule,
+  TENANT_CONTEXT_PROVIDER,
+  TenantContextProvider,
+} from '@nestarc/feature-flag';
+
+@Injectable()
+class MyTenantProvider implements TenantContextProvider {
+  getCurrentTenantId(): string | null {
+    // your custom tenant resolution logic
+    return 'tenant-from-custom-source';
+  }
+}
+
+@Module({
+  imports: [FeatureFlagModule.forRoot({ ... })],
+  providers: [
+    { provide: TENANT_CONTEXT_PROVIDER, useClass: MyTenantProvider },
+  ],
+})
+export class AppModule {}
+```
+
+## Examples
+
+- [examples/basic-guard](examples/basic-guard) - route gating with `@FeatureFlag()`
+- [examples/multi-tenant-targeting](examples/multi-tenant-targeting) - tenant and plan targeting with attributes
+- [examples/redis-events](examples/redis-events) - Redis cache invalidation and feature flag events
+
+## Performance
+
+Measured with PostgreSQL 16, Prisma 6, 500 iterations on Apple Silicon:
+
+| Scenario | Avg | P50 | P95 | P99 |
+|----------|-----|-----|-----|-----|
+| **isEnabled() — cache hit** | **0.04ms** | **0.03ms** | **0.05ms** | **0.07ms** |
+| isEnabled() — cache miss (DB lookup) | 1.30ms | 1.14ms | 2.54ms | 3.69ms |
+| isEnabled() — override cascade (cold) | 1.07ms | 1.02ms | 1.43ms | 2.11ms |
+| **evaluateAll() — 50 flags (mixed)** | **0.19ms** | **0.04ms** | **1.55ms** | **1.71ms** |
+
+Cache speedup: **32.5x** (hit vs miss). Keep the default 30s cache TTL for optimal performance.
+
+> Reproduce: `docker compose up -d && dotenv -e .env.test -- npx ts-node benchmarks/evaluation-overhead.ts`
+
 ## License
 
 MIT

package/dist/admin/admin-options.interface.d.ts

@@ -0,0 +1,5 @@
+import { CanActivate, Type } from '@nestjs/common';
+export interface FeatureFlagAdminOptions {
+    guard: Type<CanActivate>;
+    path?: string;
+}

package/dist/admin/admin-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=admin-options.interface.js.map

package/dist/admin/admin-options.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-options.interface.js","sourceRoot":"","sources":["../../src/admin/admin-options.interface.ts"],"names":[],"mappings":""}

package/dist/admin/feature-flag-admin.controller.d.ts

@@ -0,0 +1,14 @@
+import { FeatureFlagService } from '../services/feature-flag.service';
+import { FeatureFlagWithOverrides } from '../interfaces/feature-flag.interface';
+import { CreateFeatureFlagDto, RemoveOverrideDto, SetOverrideDto, UpdateFeatureFlagDto } from './feature-flag-admin.dto';
+export declare class FeatureFlagAdminController {
+    private readonly service;
+    constructor(service: FeatureFlagService);
+    create(input: CreateFeatureFlagDto): Promise<FeatureFlagWithOverrides>;
+    findAll(): Promise<FeatureFlagWithOverrides[]>;
+    findByKey(key: string): Promise<FeatureFlagWithOverrides>;
+    update(key: string, input: UpdateFeatureFlagDto): Promise<FeatureFlagWithOverrides>;
+    archive(key: string): Promise<FeatureFlagWithOverrides>;
+    setOverride(key: string, input: SetOverrideDto): Promise<void>;
+    removeOverride(key: string, input: RemoveOverrideDto): Promise<void>;
+}

package/dist/admin/feature-flag-admin.controller.js

@@ -0,0 +1,106 @@
+"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.FeatureFlagAdminController = void 0;
+const common_1 = require("@nestjs/common");
+const feature_flag_service_1 = require("../services/feature-flag.service");
+const feature_flag_admin_dto_1 = require("./feature-flag-admin.dto");
+let FeatureFlagAdminController = class FeatureFlagAdminController {
+    constructor(service) {
+        this.service = service;
+    }
+    create(input) {
+        return this.service.create(input);
+    }
+    findAll() {
+        return this.service.findAll();
+    }
+    findByKey(key) {
+        return this.service.findByKey(key);
+    }
+    update(key, input) {
+        return this.service.update(key, input);
+    }
+    archive(key) {
+        return this.service.archive(key);
+    }
+    setOverride(key, input) {
+        return this.service.setOverride(key, input);
+    }
+    removeOverride(key, input) {
+        return this.service.removeOverride(key, input);
+    }
+};
+exports.FeatureFlagAdminController = FeatureFlagAdminController;
+__decorate([
+    (0, common_1.Post)(),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [feature_flag_admin_dto_1.CreateFeatureFlagDto]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "create", null);
+__decorate([
+    (0, common_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "findAll", null);
+__decorate([
+    (0, common_1.Get)(':key'),
+    __param(0, (0, common_1.Param)('key')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "findByKey", null);
+__decorate([
+    (0, common_1.Patch)(':key'),
+    __param(0, (0, common_1.Param)('key')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, feature_flag_admin_dto_1.UpdateFeatureFlagDto]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "update", null);
+__decorate([
+    (0, common_1.Delete)(':key'),
+    __param(0, (0, common_1.Param)('key')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "archive", null);
+__decorate([
+    (0, common_1.Post)(':key/overrides'),
+    __param(0, (0, common_1.Param)('key')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, feature_flag_admin_dto_1.SetOverrideDto]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "setOverride", null);
+__decorate([
+    (0, common_1.Delete)(':key/overrides'),
+    __param(0, (0, common_1.Param)('key')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, feature_flag_admin_dto_1.RemoveOverrideDto]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "removeOverride", null);
+exports.FeatureFlagAdminController = FeatureFlagAdminController = __decorate([
+    (0, common_1.Controller)(),
+    (0, common_1.UsePipes)(new common_1.ValidationPipe({
+        whitelist: true,
+        forbidNonWhitelisted: true,
+        transform: true,
+    })),
+    __metadata("design:paramtypes", [feature_flag_service_1.FeatureFlagService])
+], FeatureFlagAdminController);
+//# sourceMappingURL=feature-flag-admin.controller.js.map

package/dist/admin/feature-flag-admin.controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag-admin.controller.js","sourceRoot":"","sources":["../../src/admin/feature-flag-admin.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAUwB;AACxB,2EAAsE;AAEtE,qEAKkC;AAU3B,IAAM,0BAA0B,GAAhC,MAAM,0BAA0B;IACrC,YAA6B,OAA2B;QAA3B,YAAO,GAAP,OAAO,CAAoB;IAAG,CAAC;IAG5D,MAAM,CAAS,KAA2B;QACxC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAGD,OAAO;QACL,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IAGD,SAAS,CAAe,GAAW;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAGD,MAAM,CACU,GAAW,EACjB,KAA2B;QAEnC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAGD,OAAO,CAAe,GAAW;QAC/B,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAGD,WAAW,CAAe,GAAW,EAAU,KAAqB;QAClE,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IAGD,cAAc,CAAe,GAAW,EAAU,KAAwB;QACxE,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;CACF,CAAA;AAxCY,gEAA0B;AAIrC;IADC,IAAA,aAAI,GAAE;IACC,WAAA,IAAA,aAAI,GAAE,CAAA;;qCAAQ,6CAAoB;;wDAEzC;AAGD;IADC,IAAA,YAAG,GAAE;;;;yDAGL;AAGD;IADC,IAAA,YAAG,EAAC,MAAM,CAAC;IACD,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;;;;2DAEtB;AAGD;IADC,IAAA,cAAK,EAAC,MAAM,CAAC;IAEX,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;IACZ,WAAA,IAAA,aAAI,GAAE,CAAA;;6CAAQ,6CAAoB;;wDAGpC;AAGD;IADC,IAAA,eAAM,EAAC,MAAM,CAAC;IACN,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;;;;yDAEpB;AAGD;IADC,IAAA,aAAI,EAAC,gBAAgB,CAAC;IACV,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;IAAe,WAAA,IAAA,aAAI,GAAE,CAAA;;6CAAQ,uCAAc;;6DAEnE;AAGD;IADC,IAAA,eAAM,EAAC,gBAAgB,CAAC;IACT,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;IAAe,WAAA,IAAA,aAAI,GAAE,CAAA;;6CAAQ,0CAAiB;;gEAEzE;qCAvCU,0BAA0B;IARtC,IAAA,mBAAU,GAAE;IACZ,IAAA,iBAAQ,EACP,IAAI,uBAAc,CAAC;QACjB,SAAS,EAAE,IAAI;QACf,oBAAoB,EAAE,IAAI;QAC1B,SAAS,EAAE,IAAI;KAChB,CAAC,CACH;qCAEuC,yCAAkB;GAD7C,0BAA0B,CAwCtC"}

package/dist/admin/feature-flag-admin.dto.d.ts

@@ -0,0 +1,22 @@
+import { TargetingAttributes } from '../interfaces/feature-flag.interface';
+export declare class CreateFeatureFlagDto {
+    key: string;
+    description?: string;
+    enabled?: boolean;
+    percentage?: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class UpdateFeatureFlagDto {
+    description?: string;
+    enabled?: boolean;
+    percentage?: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class SetOverrideDto {
+    attributes: TargetingAttributes;
+    enabled: boolean;
+    priority?: number;
+}
+export declare class RemoveOverrideDto {
+    attributes: TargetingAttributes;
+}