@nestarc/feature-flag 0.2.0 → 0.4.0

package/README.md

@@ -6,21 +6,23 @@
 [![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 -- tenant-aware overrides, percentage rollouts, and zero external dependencies.
+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
-- **Percentage rollouts** -- deterministic hashing (murmurhash3) for consistent per-user bucketing
+- **Attribute-targeted overrides** -- exact-match targeting for tenants, users, environments, plans, regions, or custom dimensions
+- **Percentage rollouts** -- deterministic hashing (murmurhash3) with explicit `targetingKey` / `bucketBy`
 - **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
+- **Programmatic evaluation** -- `isEnabled()`, `evaluateBoolean()`, and `evaluateAll()` for service-layer logic
+- **Type-safe registry helpers** -- define flag keys, defaults, rollout bucket keys, exposure tracking, and lifecycle metadata in code
 - **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
+- **OpenFeature adapter** -- optional boolean-only provider at `@nestarc/feature-flag/openfeature`
 - **Testing utilities** -- drop-in `TestFeatureFlagModule` for unit and integration tests
 
 ## Installation
@@ -32,7 +34,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
@@ -43,6 +45,9 @@ npm install @nestjs/event-emitter
 
 # Required only if you use RedisCacheAdapter
 npm install ioredis
+
+# Required only if you use the OpenFeature adapter with the SDK
+npm install @openfeature/server-sdk
 ```
 
 ## Redis Cache (Multi-Instance)
@@ -91,14 +96,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)
 
@@ -107,57 +111,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;
+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);
+```
 
--- 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;
+### Migration from 0.2.0 to 0.3.0
 
--- 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;
+v0.3.0 changes override storage from fixed `tenant_id`, `user_id`, and `environment` columns to an `attributes` `jsonb` object plus `priority`.
 
--- 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;
+Run your Prisma migrations during deployment:
 
--- 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;
+```bash
+npx prisma migrate deploy
+```
 
--- 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;
+The migration maps legacy override columns into attributes:
 
--- 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;
+| v0.2.0 column | v0.3.0 attribute |
+| ------------- | ---------------- |
+| `tenant_id` | `attributes.tenantId` |
+| `user_id` | `attributes.userId` |
+| `environment` | `attributes.environment` |
 
--- 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;
+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.
 
--- 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;
+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
 
@@ -289,6 +284,14 @@ getPremiumContent() { ... }
 
 When the flag is disabled, the guard responds with the given `statusCode` (default `403`) and optional `fallback` body.
 
+Use `defaultValue` when a route should choose an invocation-specific fallback if a flag is missing or evaluation fails:
+
+```typescript
+@FeatureFlag('OPTIONAL_PREVIEW', { defaultValue: true })
+@Get('preview')
+getPreview() { ... }
+```
+
 ### Bypassing the guard
 
 Use `@BypassFeatureFlag()` on methods that should always be accessible, even when a class-level flag is applied:
@@ -358,41 +361,136 @@ Passing `null` explicitly clears that dimension, suppressing any ambient value f
 const globalResult = await this.flags.isEnabled('MY_FLAG', { userId: null });
 ```
 
-## Overrides
+### Detailed boolean evaluation
 
-Set context-specific overrides that take precedence over the global flag value:
+Use `evaluateBoolean()` when you need to explain why a flag resolved to a value:
 
 ```typescript
-// Enable for a specific tenant
-await this.flags.setOverride('MY_FLAG', {
-  tenantId: 'tenant-1',
-  enabled: true,
-});
+const details = await this.flags.evaluateBoolean(
+  'NEW_CHECKOUT',
+  { targetingKey: 'tenant-1', tenantId: 'tenant-1' },
+  { defaultValue: false, trackExposure: true },
+);
+
+console.log(details);
+// {
+//   flagKey: 'NEW_CHECKOUT',
+//   value: true,
+//   result: true,
+//   source: 'percentage',
+//   reason: 'PERCENTAGE_MATCH',
+//   defaultUsed: false,
+//   bucket: 17,
+//   targetingKey: 'tenant-1',
+//   evaluationTimeMs: 1
+// }
+```
 
-// Disable for a specific user
-await this.flags.setOverride('MY_FLAG', {
-  userId: 'user-42',
-  enabled: false,
-});
+Missing flags and evaluation errors return the selected default instead of throwing. Default priority is:
 
-// Enable only in staging
-await this.flags.setOverride('MY_FLAG', {
-  environment: 'staging',
-  enabled: true,
+1. Invocation `defaultValue`
+2. Registry `defaultValue`
+3. Module `defaultOnMissing`
+4. `false`
+
+### Type-safe flag registry
+
+```typescript
+import { defineFlags, createFeatureFlagClient } from '@nestarc/feature-flag';
+
+export const flags = defineFlags({
+  NEW_CHECKOUT: {
+    defaultValue: false,
+    bucketBy: 'tenantId',
+    trackExposure: true,
+    owner: 'payments',
+    tags: ['checkout'],
+    staleAt: '2026-09-01',
+    expiresAt: '2026-12-01',
+  },
 });
 
-// Combine dimensions
-await this.flags.setOverride('MY_FLAG', {
+const flagClient = createFeatureFlagClient(featureFlagService, flags);
+const enabled = await flagClient.isEnabled('NEW_CHECKOUT', { tenantId: 'tenant-1' });
+```
+
+You can also pass the registry to `FeatureFlagModule.forRoot({ flags })` so service-level fallback and `bucketBy` defaults apply to direct `FeatureFlagService` calls.
+
+### OpenFeature boolean adapter
+
+The optional adapter lives on a separate subpath and delegates boolean resolution to `FeatureFlagService`:
+
+```typescript
+import { createOpenFeatureBooleanProvider } from '@nestarc/feature-flag/openfeature';
+
+const provider = createOpenFeatureBooleanProvider(featureFlagService);
+const result = await provider.resolveBooleanEvaluation(
+  'NEW_CHECKOUT',
+  false,
+  { targetingKey: 'tenant-1', tenantId: 'tenant-1', plan: 'pro' },
+);
+```
+
+Only boolean evaluation is supported in v0.4.0. Variant flags and string/number/json remote config remain out of scope.
+
+## Attribute Targeting
+
+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
+const enabled = await this.flags.isEnabled('NEW_CHECKOUT', {
+  userId: 'user-123',
   tenantId: 'tenant-1',
-  userId: 'user-42',
   environment: 'production',
+  attributes: {
+    plan: 'pro',
+    country: 'KR',
+  },
+});
+```
+
+Top-level `userId`, `tenantId`, and `environment` are merged into targeting attributes. If the same key also appears in `attributes`, the top-level value wins.
+
+When multiple overrides match, the evaluator chooses the winner by:
+
+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.
 
@@ -419,6 +517,7 @@ export class AppModule {}
 | Event constant                           | Event string                       | Payload type         |
 | ---------------------------------------- | ---------------------------------- | -------------------- |
 | `FeatureFlagEvents.EVALUATED`            | `feature-flag.evaluated`           | `FlagEvaluatedEvent` |
+| `FeatureFlagEvents.EXPOSED`              | `feature-flag.exposed`             | `FlagExposedEvent`   |
 | `FeatureFlagEvents.CREATED`              | `feature-flag.created`             | `FlagMutationEvent`  |
 | `FeatureFlagEvents.UPDATED`              | `feature-flag.updated`             | `FlagMutationEvent`  |
 | `FeatureFlagEvents.ARCHIVED`             | `feature-flag.archived`            | `FlagMutationEvent`  |
@@ -436,11 +535,13 @@ import { FeatureFlagEvents, FlagEvaluatedEvent } from '@nestarc/feature-flag';
 export class FlagAuditListener {
   @OnEvent(FeatureFlagEvents.EVALUATED)
   handleEvaluation(event: FlagEvaluatedEvent) {
-    console.log(`Flag ${event.flagKey} = ${event.result} (source: ${event.source})`);
+    console.log(`Flag ${event.flagKey} = ${event.result} (${event.reason})`);
   }
 }
 ```
 
+Exposure events are opt-in per call, registry entry, or flag metadata via `trackExposure`. They do not persist analytics; attach your own listener if you need sampling, batching, or storage.
+
 ## Testing
 
 Import `TestFeatureFlagModule` from the `/testing` subpath to stub flag values in tests without a database connection:
@@ -476,26 +577,42 @@ describe('DashboardController', () => {
 
 `TestFeatureFlagModule.register()` provides a global mock of `FeatureFlagService`:
 - `isEnabled(key)` returns the boolean you specified (defaulting to `false` for unregistered keys)
+- `evaluateBoolean(key)` returns `BooleanEvaluationDetails`
 - `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.
+For registry-based tests, use `registerRegistry()` and the injected controller:
+
+```typescript
+import {
+  TestFeatureFlagController,
+  TestFeatureFlagModule,
+} from '@nestarc/feature-flag/testing';
+
+const module = await Test.createTestingModule({
+  imports: [TestFeatureFlagModule.registerRegistry(flags)],
+}).compile();
+
+const testFlags = module.get(TestFeatureFlagController);
+testFlags.set('NEW_CHECKOUT', true);
+testFlags.reset();
+```
+
+The testing controller keeps state inside the compiled testing module. CRUD-style write methods on the mocked service still return stub objects and do not persist database rows.
 
 ## 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 + targetingKey` 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.
+Percentage rollout uses murmurhash3 for deterministic bucketing. The targeting key is resolved in this order: explicit `context.targetingKey`, registry or metadata `bucketBy`, then the legacy `userId ?? tenantId` fallback.
 
 ## Configuration Reference
 
@@ -509,6 +626,7 @@ Percentage rollout uses murmurhash3 for deterministic bucketing: the same user a
 | `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`)  |
+| `flags`             | `FlagRegistry`                    | `undefined` | Optional typed registry for defaults, `bucketBy`, and exposure settings |
 
 ### FeatureFlagModuleRootOptions
 
@@ -576,6 +694,7 @@ export class AppModule {}
 | 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/evaluate` | Evaluate a flag without mutating it | |
 | POST | `/feature-flags/:key/overrides` | Set an override | 404 flag not found |
 | DELETE | `/feature-flags/:key/overrides` | Remove an override | 404 flag not found |
 
@@ -637,6 +756,12 @@ class MyTenantProvider implements TenantContextProvider {
 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:

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

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

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

@@ -15,6 +15,7 @@ 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;
@@ -34,6 +35,10 @@ let FeatureFlagAdminController = class FeatureFlagAdminController {
     archive(key) {
         return this.service.archive(key);
     }
+    evaluate(key, input) {
+        const { context, ...options } = input;
+        return this.service.evaluateBoolean(key, context, options);
+    }
     setOverride(key, input) {
         return this.service.setOverride(key, input);
     }
@@ -46,7 +51,7 @@ __decorate([
     (0, common_1.Post)(),
     __param(0, (0, common_1.Body)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
+    __metadata("design:paramtypes", [feature_flag_admin_dto_1.CreateFeatureFlagDto]),
     __metadata("design:returntype", Promise)
 ], FeatureFlagAdminController.prototype, "create", null);
 __decorate([
@@ -67,7 +72,7 @@ __decorate([
     __param(0, (0, common_1.Param)('key')),
     __param(1, (0, common_1.Body)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:paramtypes", [String, feature_flag_admin_dto_1.UpdateFeatureFlagDto]),
     __metadata("design:returntype", Promise)
 ], FeatureFlagAdminController.prototype, "update", null);
 __decorate([
@@ -77,12 +82,20 @@ __decorate([
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], FeatureFlagAdminController.prototype, "archive", null);
+__decorate([
+    (0, common_1.Post)(':key/evaluate'),
+    __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.EvaluateFeatureFlagDto]),
+    __metadata("design:returntype", Promise)
+], FeatureFlagAdminController.prototype, "evaluate", 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, Object]),
+    __metadata("design:paramtypes", [String, feature_flag_admin_dto_1.SetOverrideDto]),
     __metadata("design:returntype", Promise)
 ], FeatureFlagAdminController.prototype, "setOverride", null);
 __decorate([
@@ -90,11 +103,16 @@ __decorate([
     __param(0, (0, common_1.Param)('key')),
     __param(1, (0, common_1.Body)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
+    __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

@@ -1 +1 @@
-{"version":3,"file":"feature-flag-admin.controller.js","sourceRoot":"","sources":["../../src/admin/feature-flag-admin.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAQwB;AACxB,2EAAsE;AAU/D,IAAM,0BAA0B,GAAhC,MAAM,0BAA0B;IACrC,YAA6B,OAA2B;QAA3B,YAAO,GAAP,OAAO,CAAoB;IAAG,CAAC;IAG5D,MAAM,CAAS,KAA6B;QAC1C,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,KAA6B;QAErC,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,CACK,GAAW,EACjB,KAAuB;QAE/B,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IAGD,cAAc,CACE,GAAW,EACjB,KAA0B;QAElC,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;CACF,CAAA;AA9CY,gEAA0B;AAIrC;IADC,IAAA,aAAI,GAAE;IACC,WAAA,IAAA,aAAI,GAAE,CAAA;;;;wDAEb;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;;;;wDAGR;AAGD;IADC,IAAA,eAAM,EAAC,MAAM,CAAC;IACN,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;;;;yDAEpB;AAGD;IADC,IAAA,aAAI,EAAC,gBAAgB,CAAC;IAEpB,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;IACZ,WAAA,IAAA,aAAI,GAAE,CAAA;;;;6DAGR;AAGD;IADC,IAAA,eAAM,EAAC,gBAAgB,CAAC;IAEtB,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;IACZ,WAAA,IAAA,aAAI,GAAE,CAAA;;;;gEAGR;qCA7CU,0BAA0B;IADtC,IAAA,mBAAU,GAAE;qCAE2B,yCAAkB;GAD7C,0BAA0B,CA8CtC"}
+{"version":3,"file":"feature-flag-admin.controller.js","sourceRoot":"","sources":["../../src/admin/feature-flag-admin.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAUwB;AACxB,2EAAsE;AAGtE,qEAMkC;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,QAAQ,CACQ,GAAW,EACjB,KAA6B;QAErC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,KAAK,CAAC;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC7D,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;AAjDY,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,eAAe,CAAC;IAEnB,WAAA,IAAA,cAAK,EAAC,KAAK,CAAC,CAAA;IACZ,WAAA,IAAA,aAAI,GAAE,CAAA;;6CAAQ,+CAAsB;;0DAItC;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;qCAhDU,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,CAiDtC"}

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

@@ -0,0 +1,30 @@
+import { EvaluationContext } from '../interfaces/evaluation-context.interface';
+import { EvaluateBooleanOptions } from '../interfaces/evaluation-details.interface';
+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;
+}
+export declare class EvaluateFeatureFlagDto implements EvaluateBooleanOptions {
+    context?: EvaluationContext;
+    defaultValue?: boolean;
+    trackExposure?: boolean;
+    includeContextInEvent?: boolean;
+}