@plyaz/core 1.2.0 → 1.2.1

package/dist/adapters/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Framework Adapters
+ *
+ * Adapters for different HTTP frameworks and runtimes.
+ *
+ * Available:
+ * - createHandler: Next.js API route handler with service injection
+ * - CoreModule: NestJS DI integration
+ *
+ * Types are available from '@plyaz/types/core':
+ * - CoreNextJsHandlerContext, CoreNextJsHandler, etc.
+ * - CoreNestJsModuleOptions, CoreNestJsModuleAsyncOptions
+ */
+export { createHandler, nextHandler } from './nextjs';
+export { CoreModule, CORE_DB_SERVICE, CORE_ENV, CORE_OPTIONS } from './nestjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGtD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}

package/dist/adapters/nestjs.d.ts

@@ -0,0 +1,79 @@
+/**
+ * NestJS Framework Adapter
+ *
+ * Provides CoreModule for NestJS dependency injection.
+ * Initializes core services (db, env) for use across NestJS modules.
+ */
+import type { DynamicModule } from '@nestjs/common';
+import type { CoreDbServiceConfig } from '../services/DbService';
+import type { CoreNestJsModuleOptions, CoreNestJsModuleAsyncOptions } from '@plyaz/types/core';
+/**
+ * Core module options for NestJS
+ * Extended with specific DbServiceConfig type
+ */
+interface CoreModuleOptions extends Omit<CoreNestJsModuleOptions, 'db'> {
+    /** Database configuration */
+    db?: CoreDbServiceConfig;
+}
+/**
+ * Async options for CoreModule
+ * Extended with specific CoreModuleOptions type
+ */
+interface CoreModuleAsyncOptions extends Omit<CoreNestJsModuleAsyncOptions, 'useFactory'> {
+    useFactory: (...args: unknown[]) => CoreModuleOptions | Promise<CoreModuleOptions>;
+}
+/**
+ * Injection tokens for Core services
+ */
+export declare const CORE_DB_SERVICE = "CORE_DB_SERVICE";
+export declare const CORE_ENV = "CORE_ENV";
+export declare const CORE_OPTIONS = "CORE_OPTIONS";
+/**
+ * CoreModule for NestJS
+ *
+ * Provides Core services (DbService, etc.) via NestJS dependency injection.
+ * Import additional modules (FeatureFlagModule, etc.) separately.
+ *
+ * @example
+ * ```typescript
+ * import { Module } from '@nestjs/common';
+ * import { CoreModule } from '@plyaz/core/adapters';
+ * import { FeatureFlagModule } from '@plyaz/core/backend/featureFlags';
+ *
+ * @Module({
+ *   imports: [
+ *     CoreModule.forRoot({ envPath: '.env' }),
+ *     FeatureFlagModule.forRoot({ provider: 'database' }), // Auto-receives DbService
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example Async configuration
+ * ```typescript
+ * CoreModule.forRootAsync({
+ *   imports: [ConfigModule],
+ *   inject: [ConfigService],
+ *   useFactory: (config: ConfigService) => ({
+ *     db: {
+ *       adapter: 'drizzle',
+ *       drizzle: {
+ *         connectionString: config.get('DATABASE_URL'),
+ *       },
+ *     },
+ *   }),
+ * })
+ * ```
+ */
+export declare const CoreModule: {
+    /**
+     * Register CoreModule with static configuration
+     */
+    forRoot(options?: CoreModuleOptions): DynamicModule;
+    /**
+     * Register CoreModule with async configuration
+     */
+    forRootAsync(options: CoreModuleAsyncOptions): DynamicModule;
+};
+export {};
+//# sourceMappingURL=nestjs.d.ts.map

package/dist/adapters/nestjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs.d.ts","sourceRoot":"","sources":["../../src/adapters/nestjs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAG/F;;;GAGG;AACH,UAAU,iBAAkB,SAAQ,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC;IACrE,6BAA6B;IAC7B,EAAE,CAAC,EAAE,mBAAmB,CAAC;CAC1B;AAED;;;GAGG;AACH,UAAU,sBAAuB,SAAQ,IAAI,CAAC,4BAA4B,EAAE,YAAY,CAAC;IACvF,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACpF;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,oBAAoB,CAAC;AACjD,eAAO,MAAM,QAAQ,aAAa,CAAC;AACnC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;sBACc,iBAAiB,GAAQ,aAAa;IAsCvD;;OAEG;0BACmB,sBAAsB,GAAG,aAAa;CAyC7D,CAAC"}

package/dist/adapters/nextjs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Next.js Adapter
+ *
+ * Provides utilities for Next.js API routes with auto-initialization
+ * and service injection.
+ *
+ * @example
+ * ```typescript
+ * // app/api/users/route.ts
+ * import { createHandler } from '@plyaz/core/adapters';
+ *
+ * export const GET = createHandler(async ({ db, query }) => {
+ *   const users = await db.list('users');
+ *   return { users };
+ * });
+ *
+ * export const POST = createHandler(async ({ db, body }) => {
+ *   const user = await db.create('users', body);
+ *   return { user, status: 201 };
+ * });
+ * ```
+ */
+import type { CoreNextJsHandler, CoreNextJsHandlerOptions } from '@plyaz/types/core';
+export declare function createHandler(handler: CoreNextJsHandler, options?: CoreNextJsHandlerOptions): (request: Request, context?: {
+    params?: Record<string, string>;
+}) => Promise<Response>;
+export { createHandler as nextHandler };
+//# sourceMappingURL=nextjs.d.ts.map

package/dist/adapters/nextjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../src/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAEV,iBAAiB,EACjB,wBAAwB,EAEzB,MAAM,mBAAmB,CAAC;AAgI3B,wBAAgB,aAAa,CAC3B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,wBAAwB,GACjC,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAcxF;AAGD,OAAO,EAAE,aAAa,IAAI,WAAW,EAAE,CAAC"}

package/dist/backend/example/example.controller.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Example Controller
+ *
+ * Simple NestJS controller demonstrating Core + BackendExampleDomainService integration.
+ * Use as reference for building your own backend modules.
+ *
+ * Demonstrates:
+ * - Standard CRUD operations with error handling
+ * - Single error throwing (standard pattern)
+ * - Array error throwing (multiple validation errors)
+ * - Standard API response format using SuccessResponseStandard
+ * - How errors are automatically captured and returned as ErrorResponse
+ */
+import { BackendExampleDomainService } from '../../domain/example';
+import type { ExampleEntity, CreateExampleDTO, PatchExampleDTO } from '@plyaz/types/examples';
+import type { ReturnResponseType } from '@plyaz/types/errors';
+export declare const BACKEND_EXAMPLE_DOMAIN_SERVICE = "BACKEND_EXAMPLE_DOMAIN_SERVICE";
+/**
+ * Example Controller
+ *
+ * Routes:
+ * - GET  /example/health                  - Health check
+ * - GET  /example/entities/:id            - Get entity by ID
+ * - POST /example/entities                - Create entity
+ * - PATCH /example/entities/:id           - Update entity
+ * - DELETE /example/entities/:id          - Delete entity
+ * - POST /example/entities/validated      - Create with full validation (array errors example)
+ * - GET  /example/errors/single           - Demo: Single error response
+ * - GET  /example/errors/array            - Demo: Array of errors response
+ */
+export declare class ExampleController {
+    private readonly exampleService;
+    constructor(exampleService: BackendExampleDomainService);
+    /**
+     * Health check endpoint
+     * GET /example/health
+     */
+    health(): ReturnResponseType<{
+        service: boolean;
+        timestamp: string;
+    }>;
+    /**
+     * Get entity by ID
+     * GET /example/entities/:id
+     */
+    getEntity(id: string): Promise<ReturnResponseType<ExampleEntity | null>>;
+    /**
+     * Create a new entity
+     * POST /example/entities
+     *
+     * Example success response:
+     * ```json
+     * {
+     *   "success": true,
+     *   "message": "Entity created successfully",
+     *   "data": { ... },
+     *   "codeStatus": 201
+     * }
+     * ```
+     */
+    createEntity(dto: CreateExampleDTO): Promise<ReturnResponseType<ExampleEntity>>;
+    /**
+     * Update an entity (partial)
+     * PATCH /example/entities/:id
+     */
+    updateEntity(id: string, dto: PatchExampleDTO): Promise<ReturnResponseType<ExampleEntity>>;
+    /**
+     * Delete an entity
+     * DELETE /example/entities/:id
+     */
+    deleteEntity(id: string): Promise<ReturnResponseType<null>>;
+    /**
+     * Create entity with full validation (array errors pattern)
+     * POST /example/entities/validated
+     *
+     * Demonstrates validator throwing validation errors.
+     * The validator.validateCreateOrThrow() will automatically throw all validation errors as an array.
+     *
+     * Example success response:
+     * ```json
+     * {
+     *   "success": true,
+     *   "message": "Entity created successfully",
+     *   "data": { ... },
+     *   "codeStatus": 201
+     * }
+     * ```
+     */
+    createEntityWithValidation(dto: unknown): Promise<ReturnResponseType<ExampleEntity>>;
+    /**
+     * Demo: Single validation error response
+     * GET /example/errors/single
+     *
+     * Demonstrates validator throwing a SINGLE validation error.
+     * Service uses validateCreateOrThrow() with ONE invalid field.
+     *
+     * Response: HTTP 400
+     * ```json
+     * [{ "code": "VALIDATION_FAILED", "message": "Name is required", "field": "name" }]
+     * ```
+     */
+    demoSingleError(): Promise<void>;
+    /**
+     * Demo: Multiple validation errors response
+     * GET /example/errors/array
+     *
+     * Demonstrates validator throwing MULTIPLE validation errors.
+     * Service uses validateCreateOrThrow() with MULTIPLE invalid fields.
+     *
+     * Response: HTTP 400
+     * ```json
+     * [
+     *   { "code": "VALIDATION_FAILED", "message": "Name is required", "field": "name" },
+     *   { "code": "VALIDATION_FAILED", "message": "Amount must be non-negative", "field": "amount" },
+     *   { "code": "VALIDATION_FAILED", "message": "Description is required", "field": "description" }
+     * ]
+     * ```
+     */
+    demoArrayErrors(): Promise<void>;
+}
+//# sourceMappingURL=example.controller.d.ts.map

package/dist/backend/example/example.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.controller.d.ts","sourceRoot":"","sources":["../../../src/backend/example/example.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAcH,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC9F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAI9D,eAAO,MAAM,8BAA8B,mCAAmC,CAAC;AAE/E;;;;;;;;;;;;GAYG;AACH,qBACa,iBAAiB;IAG1B,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAAd,cAAc,EAAE,2BAA2B;IAG9D;;;OAGG;IAEH,MAAM,IAAI,kBAAkB,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAOrE;;;OAGG;IAEG,SAAS,CAAc,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IAK3F;;;;;;;;;;;;;OAaG;IAGG,YAAY,CAAS,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;IAK7F;;;OAGG;IAEG,YAAY,CACH,EAAE,EAAE,MAAM,EACf,GAAG,EAAE,eAAe,GAC3B,OAAO,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;IAK7C;;;OAGG;IAGG,YAAY,CAAc,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAK9E;;;;;;;;;;;;;;;;OAgBG;IAGG,0BAA0B,CACtB,GAAG,EAAE,OAAO,GACnB,OAAO,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;IAW7C;;;;;;;;;;;OAWG;IAEG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC;;;;;;;;;;;;;;;OAeG;IAEG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;CAIvC"}

package/dist/backend/example/example.module.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Example Module
+ *
+ * NestJS module demonstrating the proper pattern using domain service directly:
+ * Module → Controller → BackendExampleService
+ *
+ * The BackendExampleService is auto-initialized by Core.initialize() and
+ * can be injected via ServiceRegistry or provided directly to controllers.
+ *
+ * @example Usage in app.module.ts
+ * ```typescript
+ * import { CoreModule } from '@plyaz/core/nestjs';
+ * import { ExampleModule } from '@plyaz/core';
+ *
+ * @Module({
+ *   imports: [
+ *     CoreModule.forRoot({ envPath: '.env' }),
+ *     ExampleModule,
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+import { BACKEND_EXAMPLE_DOMAIN_SERVICE } from './example.controller';
+import { BackendExampleDomainService } from '../../domain/example';
+export declare class ExampleModule {
+}
+export { BackendExampleDomainService, BACKEND_EXAMPLE_DOMAIN_SERVICE };
+//# sourceMappingURL=example.module.d.ts.map

package/dist/backend/example/example.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.module.d.ts","sourceRoot":"","sources":["../../../src/backend/example/example.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAqB,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAA+B,MAAM,sBAAsB,CAAC;AAEhG,qBAYa,aAAa;CAAG;AAG7B,OAAO,EAAE,2BAA2B,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/backend/example/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Example Module Exports
+ *
+ * Pattern: Module → Controller → BackendExampleDomainService (from domain)
+ */
+export { ExampleModule, BACKEND_EXAMPLE_DOMAIN_SERVICE, BackendExampleDomainService, } from './example.module';
+export { ExampleController } from './example.controller';
+//# sourceMappingURL=index.d.ts.map

package/dist/backend/example/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/example/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,aAAa,EACb,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/backend/featureFlags/FeatureFlagDomainService.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Feature Flag Domain Service (Backend)
+ *
+ * Backend-specific domain service that extends BaseDomainService and
+ * uses providers (database, redis, memory, etc.) to manage feature flags.
+ *
+ * Runtime: Backend only (uses providers, no API calls)
+ *
+ * @example
+ * ```typescript
+ * // Create service instance with a provider
+ * const provider = new DatabaseFeatureFlagProvider(config, FEATURES);
+ * await provider.initialize();
+ *
+ * const flagService = new FeatureFlagDomainService({
+ *   enabled: true,
+ *   provider,
+ * });
+ *
+ * // Use the service
+ * const isEnabled = await flagService.isEnabled('new-feature', { userId: 'user-123' });
+ * ```
+ */
+import type { FeatureFlag, FeatureFlagRule, FeatureFlagContext, FeatureFlagValue, FeatureFlagEvaluation, CreateFlagRequest } from '@plyaz/types';
+import { BaseDomainService } from '../../domain/base';
+import type { FeatureFlagDomainServiceConfig as _FeatureFlagDomainServiceConfig, FeatureFlagDomainEventType } from '@plyaz/types/features';
+/**
+ * Feature Flag Backend Service
+ *
+ * Extends BaseDomainService with generics for strong typing.
+ * Uses an injected provider (database, redis, memory, etc.) for data access.
+ *
+ * No mapper/validator as this service handles simple flag values.
+ * No API client - uses provider directly for data access.
+ */
+export declare class FeatureFlagDomainService extends BaseDomainService<_FeatureFlagDomainServiceConfig> {
+    /** The feature flag provider */
+    private readonly provider;
+    constructor(config: _FeatureFlagDomainServiceConfig);
+    /**
+     * Check if service is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Dispose/cleanup the service
+     */
+    dispose(): void;
+    /**
+     * Refresh the provider cache
+     */
+    refresh(): Promise<void>;
+    /**
+     * Evaluate a single feature flag
+     *
+     * @param key - Feature flag key
+     * @param context - Evaluation context (user, environment, etc.)
+     * @returns Full evaluation result
+     */
+    evaluate(key: string, context?: FeatureFlagContext): Promise<FeatureFlagEvaluation<string>>;
+    /**
+     * Check if a feature flag is enabled
+     *
+     * @param key - Feature flag key
+     * @param context - Evaluation context
+     * @returns Boolean indicating if flag is enabled
+     */
+    isEnabled(key: string, context?: FeatureFlagContext): Promise<boolean>;
+    /**
+     * Get the value of a feature flag
+     *
+     * @param key - Feature flag key
+     * @param context - Evaluation context
+     * @returns The flag value
+     */
+    getValue<T = FeatureFlagValue>(key: string, context?: FeatureFlagContext): Promise<T>;
+    /**
+     * Evaluate all feature flags for a context
+     *
+     * @param context - Evaluation context
+     * @returns Record of all flag evaluations
+     */
+    evaluateAll(context?: FeatureFlagContext): Promise<Record<string, FeatureFlagEvaluation<string>>>;
+    /**
+     * Create a new feature flag
+     *
+     * @param data - Flag creation data
+     * @returns The created feature flag
+     */
+    create(data: CreateFlagRequest<string>): Promise<FeatureFlag<string>>;
+    /**
+     * Update an existing feature flag
+     *
+     * @param key - Flag key to update
+     * @param data - Partial update data
+     * @returns The updated feature flag
+     */
+    update(key: string, data: Partial<CreateFlagRequest<string>>): Promise<FeatureFlag<string>>;
+    /**
+     * Delete a feature flag
+     *
+     * @param key - Flag key to delete
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Get rules for a specific flag
+     *
+     * @param key - Flag key
+     * @returns Array of rules
+     */
+    getRules(key: string): Promise<FeatureFlagRule<string>[]>;
+    /**
+     * Get all rules
+     *
+     * @returns Array of all rules
+     */
+    getAllRules(): Promise<FeatureFlagRule<string>[]>;
+    /**
+     * Set a runtime override for a flag (in-memory, not persisted)
+     *
+     * @param key - Flag key
+     * @param value - Override value
+     */
+    setOverride(key: string, value: FeatureFlagValue): void;
+    /**
+     * Remove a runtime override for a flag
+     *
+     * @param key - Flag key
+     */
+    removeOverride(key: string): void;
+    /**
+     * Clear all runtime overrides
+     */
+    clearOverrides(): void;
+    /**
+     * Subscribe to provider changes
+     *
+     * @param callback - Callback when flags change
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Subscribe to feature flag events
+     *
+     * @param event - Event type to subscribe to
+     * @param handler - Event handler
+     * @returns Unsubscribe function
+     */
+    on(event: FeatureFlagDomainEventType, handler: (data: unknown) => void): () => void;
+}
+//# sourceMappingURL=FeatureFlagDomainService.d.ts.map

package/dist/backend/featureFlags/FeatureFlagDomainService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureFlagDomainService.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/FeatureFlagDomainService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EAElB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAQtD,OAAO,KAAK,EACV,8BAA8B,IAAI,+BAA+B,EACjE,0BAA0B,EAC3B,MAAM,uBAAuB,CAAC;AAM/B;;;;;;;;GAQG;AACH,qBAAa,wBAAyB,SAAQ,iBAAiB,CAAC,+BAA+B,CAAC;IAC9F,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;gBAM3C,MAAM,EAAE,+BAA+B;IA4BnD;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,OAAO,IAAI,IAAI;IAYf;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAW9B;;;;;;OAMG;IACG,QAAQ,CACZ,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAgBzC;;;;;;OAMG;IACG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAM5E;;;;;;OAMG;IACG,QAAQ,CAAC,CAAC,GAAG,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAM3F;;;;;OAKG;IACG,WAAW,CACf,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC;IAiBzD;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAgB3E;;;;;;OAMG;IACG,MAAM,CACV,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,GACvC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAgB/B;;;;OAIG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxC;;;;;OAKG;IACG,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC;IAY/D;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC;IAgBvD;;;;;OAKG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI;IASvD;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASjC;;OAEG;IACH,cAAc,IAAI,IAAI;IAUtB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAS3C;;;;;;OAMG;IACH,EAAE,CAAC,KAAK,EAAE,0BAA0B,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI;CAGpF"}

package/dist/backend/featureFlags/config/feature-flag.config.d.ts

@@ -5,7 +5,8 @@
  * Imports configuration from .env.local and provides validation.
  *
  */
-import { type FeatureFlagEnvironmentConfig } from '@plyaz/types';
+import { type CoreFeatureFlagEnvironmentConfig } from '@plyaz/types/core';
+import type { FeatureFlagConfigOptions as _FeatureFlagConfigOptions } from '@plyaz/types/features';
 /**
  * Feature flag configuration factory
  *
@@ -15,7 +16,7 @@ import { type FeatureFlagEnvironmentConfig } from '@plyaz/types';
  * @example
  * ```typescript
  * // Step 1: Called automatically by FeatureFlagService.onModuleInit()
- * const config = FeatureFlagConfigFactory.fromEnvironment();
+ * const config = FeatureFlagConfigFactory.fromOptions({ environment: Core.env.NODE_ENV });
  *
  * // Step 2: Configuration is validated
  * // Step 3: Provider is created with this config
@@ -48,64 +49,41 @@ export declare class FeatureFlagConfigFactory {
      * 7. → Database connection established
      *
      * @returns Validated configuration object ready for provider creation
-     * @throws {FeatureFlagConfigError} If environment variables are missing or invalid
-     *
-     * @example
-     * ```typescript
-     * // This method reads from process.env and creates:
-     * {
-     *   provider: 'database',
-     *   isCacheEnabled: true,
-     *   cacheTtl: 300,
-     *   databaseConfig: {
-     *     connectionString: 'https://your-project.supabase.co',
-     *     tableName: 'feature_flags',
-     *     poolSize: 10,
-     *     timeout: 30000
-     *   }
-     * }
-     * ```
+     * @throws {FeatureFlagConfigError} If required options are missing or invalid
      */
-    static fromEnvironment(): FeatureFlagEnvironmentConfig;
     /**
-     * Determines which provider to use - now uses constants instead of environment variables
+     * Creates configuration from explicit options
      *
-     * @private
-     * @returns Provider type from constants
-     */
-    private static getProvider;
-    private static getCacheEnabled;
-    private static getCacheTtl;
-    private static getRefreshInterval;
-    private static getLoggingEnabled;
-    /**
-     * Creates database configuration from environment variables
+     * All options have sensible defaults - only provide what you need to override.
+     * Environment is automatically read from Core.env.NODE_ENV.
      *
-     * **CRITICAL**: This method requires SUPABASE_URL to be set in .env.local
+     * Note: For 'database' provider, DbService must be initialized first via Core.initialize().
+     * The database provider uses the already-configured DbService, no connection string needed here.
      *
-     * @private
-     * @returns Database configuration object
-     * @throws {FeatureFlagConfigError} If SUPABASE_URL is missing
+     * @example Basic usage with defaults (memory provider)
+     * ```typescript
+     * const config = FeatureFlagConfigFactory.fromOptions();
+     * // Uses memory provider, cache enabled, default TTL
+     * ```
+     *
+     * @example Database provider (requires Core.initialize() first)
+     * ```typescript
+     * // First: Core.initialize() with db config
+     * await Core.initialize({ db: { adapter: 'sql', sql: { connectionString: '...' } } });
      *
-     * @example Environment Variables Required:
-     * ```bash
-     * SUPABASE_URL=https://your-project.supabase.co          # REQUIRED
-     * SUPABASE_ANON_PUBLIC_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... # Used in connection
-     * FEATURE_FLAG_TABLE_NAME=feature_flags                           # Optional, defaults to 'feature_flags'
-     * DB_POOL_SIZE=10                                                 # Optional, defaults to 10
-     * DB_TIMEOUT=30000                                                # Optional, defaults to 30000ms
+     * // Then: Use database provider for feature flags
+     * const config = FeatureFlagConfigFactory.fromOptions({ provider: 'database' });
      * ```
      *
-     * @example Generated Configuration:
+     * @example Custom cache settings
      * ```typescript
-     * {
-     *   connectionString: 'https://your-project.supabase.co',
-     *   tableName: 'feature_flags',
-     *   poolSize: 10,
-     *   timeout: 30000
-     * }
+     * const config = FeatureFlagConfigFactory.fromOptions({
+     *   cacheEnabled: true,
+     *   cacheTtl: 600,  // 10 minutes
+     *   refreshInterval: 30,
+     * });
      * ```
      */
-    private static getDatabaseConfig;
+    static fromOptions(options?: _FeatureFlagConfigOptions): CoreFeatureFlagEnvironmentConfig;
 }
 //# sourceMappingURL=feature-flag.config.d.ts.map

package/dist/backend/featureFlags/config/feature-flag.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flag.config.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/config/feature-flag.config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAKL,KAAK,4BAA4B,EAGlC,MAAM,cAAc,CAAC;AAItB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,wBAAwB;IACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,MAAM,CAAC,eAAe,IAAI,4BAA4B;IAmBtD;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,eAAe;IAI9B,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAIjC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAOhC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAgBjC"}
+{"version":3,"file":"feature-flag.config.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/config/feature-flag.config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAIL,KAAK,gCAAgC,EACtC,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EAAE,wBAAwB,IAAI,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAEnG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,wBAAwB;IACnC;;;;;;;;;;;;;;;;OAgBG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IAEH,MAAM,CAAC,WAAW,CAAC,OAAO,GAAE,yBAA8B,GAAG,gCAAgC;CA+B9F"}

package/dist/backend/featureFlags/config/validation.d.ts

@@ -5,7 +5,7 @@
  * Provides error reporting and environment-specific validation.
  *
  */
-import { type FeatureFlagEnvironmentConfig, type FeatureFlagValidationResult } from '@plyaz/types';
+import { type CoreFeatureFlagEnvironmentConfig, type CoreFeatureFlagValidationResult } from '@plyaz/types/core';
 /**
  * FeatureFlagConfigValidator - Comprehensive configuration validation for feature flags
  *
@@ -121,7 +121,7 @@ export declare class FeatureFlagConfigValidator {
      * // ]
      * ```
      */
-    static validate(config: FeatureFlagEnvironmentConfig): FeatureFlagValidationResult;
+    static validate(config: CoreFeatureFlagEnvironmentConfig): CoreFeatureFlagValidationResult;
     private static validateProvider;
     private static validateCacheSettings;
     private static validateDatabaseConfig;
@@ -138,13 +138,13 @@ export declare class FeatureFlagConfigValidator {
      * to ensure the system doesn't start with invalid configuration.
      *
      * @param {FeatureFlagEnvironmentConfig} config - Configuration to validate
-     * @throws {DatabaseError} When validation fails with detailed error messages
+     * @throws {DatabasePackageError} When validation fails with detailed error messages
      *
      * @example Startup Validation
      * ```typescript
      * // In FeatureFlagService.onModuleInit()
      * try {
-     *   const config = FeatureFlagConfigFactory.fromEnvironment();
+     *   const config = FeatureFlagConfigFactory.fromOptions();
      *   FeatureFlagConfigValidator.validateOrThrow(config);
      *
      *   // Configuration is valid, proceed with initialization
@@ -158,7 +158,7 @@ export declare class FeatureFlagConfigValidator {
      *
      * @example Error Output
      * ```typescript
-     * // When validation fails, throws DatabaseError with message:
+     * // When validation fails, throws DatabasePackageError with message:
      * // "Configuration validation failed:
      * // provider: Invalid provider: invalid_type. Must be one of: memory, file, redis, api, database
      * // cacheTtl: Cache TTL must be non-negative
@@ -176,6 +176,6 @@ export declare class FeatureFlagConfigValidator {
      * # databaseConfig.connectionString: Database connection string is required"
      * ```
      */
-    static validateOrThrow(config: FeatureFlagEnvironmentConfig): void;
+    static validateOrThrow(config: CoreFeatureFlagEnvironmentConfig): void;
 }
 //# sourceMappingURL=validation.d.ts.map

package/dist/backend/featureFlags/config/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/config/validation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAGjC,MAAM,cAAc,CAAC;AAKtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,0BAA0B;IACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,4BAA4B,GAAG,2BAA2B;IAiClF,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAY/B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAkBpC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiBrC,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAoBvC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAUhC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B,OAAO,CAAC,MAAM,CAAC,eAAe;IAU9B,OAAO,CAAC,MAAM,CAAC,WAAW;IA+B1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,4BAA4B,GAAG,IAAI;CAYnE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/config/validation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,KAAK,gCAAgC,EACrC,KAAK,+BAA+B,EACrC,MAAM,mBAAmB,CAAC;AAY3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,0BAA0B;IACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,gCAAgC,GAAG,+BAA+B;IAiC1F,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAY/B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAkBpC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiBrC,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAoBvC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAUhC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B,OAAO,CAAC,MAAM,CAAC,eAAe;IAU9B,OAAO,CAAC,MAAM,CAAC,WAAW;IAqC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,gCAAgC,GAAG,IAAI;CAYvE"}