@plyaz/core 1.0.0

package/README.md

@@ -0,0 +1,439 @@
+# @plyaz/core
+
+> Foundational full-stack package for the Plyaz ecosystem
+
+The `@plyaz/core` package serves as the orchestration layer that combines functionality from specialized packages to provide core business logic, domain models, and SDK foundations.
+
+## 🎯 Key Objectives
+
+- **Business Logic Orchestration**: Centralize core business logic that coordinates between specialized packages
+- **Full-Stack Support**: Environment-aware conditional loading for frontend, backend, and B2B integrations
+- **SDK Foundations**: Standardized interfaces for B2B partnerships and external integrations
+- **Type Safety**: Maintain strict architectural boundaries across all environments
+
+## 🏗️ Architecture Philosophy
+
+`@plyaz/core` acts as the **orchestration layer** - it doesn't reimplement functionality but coordinates between specialized packages:
+
+```typescript
+// Core orchestrates other packages
+import { getUser, createTransaction } from '@plyaz/api';
+import { executeSmartContract, getWalletBalance } from '@plyaz/web3';
+import { validateUser, checkPermissions } from '@plyaz/auth';
+import { trackBusinessMetric } from '@plyaz/monitoring';
+import { FEATURE_FLAGS } from '@plyaz/config';
+import { createLogger } from '@plyaz/logger';
+```
+
+## 📁 Package Structure
+
+```
+@plyaz/core/
+├── src/
+│   ├── cache/                  # Business logic caching layer
+│   ├── domain/                 # Pure business domain logic
+│   │   ├── user/              # User entity models and business rules
+│   │   ├── asset/             # Digital asset models and economics
+│   │   ├── transaction/       # Transaction domain and validation
+│   │   └── community/         # Community governance and interaction
+│   ├── engine/                # Core computational engines
+│   │   ├── calculation/       # Mathematical computation algorithms
+│   │   ├── incentive/         # Reward and incentive systems
+│   │   ├── validation/        # Business rule validation engines
+│   │   └── insights/          # Data analysis and pattern recognition
+│   ├── feature-flags/         # Complete feature flag system
+│   ├── frontend/              # Frontend-specific implementations
+│   ├── backend/               # Backend-specific implementations
+│   ├── sdk/                   # B2B SDK foundation
+│   └── contracts/             # External service contracts
+```
+
+## 🚀 Feature Flag System
+
+The feature flag system is currently the most mature component of `@plyaz/core`:
+
+### Backend Integration (NestJS)
+
+```typescript
+// app.module.ts
+import { FeatureFlagModule } from '@plyaz/core/backend';
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRoot({
+      provider: 'redis',
+      isCacheEnabled: true,
+      cacheTtl: 600,
+      redisConfig: { url: 'redis://localhost:6379' }
+    })
+  ],
+})
+export class AppModule {}
+
+// my.service.ts
+import { FeatureFlagService } from '@plyaz/core/backend';
+
+@Injectable()
+export class MyService {
+  constructor(private featureFlagService: FeatureFlagService) {}
+
+  async processPayment(userId: string) {
+    const isEnabled = await this.featureFlagService.isEnabled('NEW_PAYMENT_FLOW', {
+      userId,
+      environment: 'production'
+    });
+    
+    if (isEnabled) {
+      // New payment implementation
+    } else {
+      // Legacy payment implementation
+    }
+  }
+}
+```
+
+### Backend Integration (Express/Node.js)
+
+```typescript
+// server.js
+import { MemoryFeatureFlagProvider } from '@plyaz/core/domain';
+import { FEATURES } from '@plyaz/config';
+
+// Initialize provider
+const featureFlagProvider = new MemoryFeatureFlagProvider({
+  provider: 'memory',
+  isCacheEnabled: true,
+  cacheTtl: 300
+}, FEATURES);
+
+await featureFlagProvider.initialize();
+
+// Use in routes
+app.get('/api/features/:key', async (req, res) => {
+  const evaluation = await featureFlagProvider.getFlag(req.params.key, {
+    userId: req.user?.id,
+    environment: process.env.NODE_ENV
+  });
+  
+  res.json(evaluation);
+});
+```
+
+### Frontend Integration (React)
+
+```typescript
+// App.tsx
+import { FeatureFlagAppProvider } from '@plyaz/core/frontend';
+import { FEATURES } from '@plyaz/config';
+
+function App() {
+  return (
+    <FeatureFlagAppProvider
+      config={{
+        provider: 'api',
+        apiEndpoint: 'https://api.example.com/feature-flags',
+        isCacheEnabled: true,
+        cacheTtl: 300
+      }}
+      features={FEATURES}
+    >
+      <MyApplication />
+    </FeatureFlagAppProvider>
+  );
+}
+
+// Component.tsx
+import { useFeatureFlag, useFeatureFlagEnabled } from '@plyaz/core/frontend';
+
+function PaymentComponent() {
+  // Full feature flag data with loading state
+  const { value, isLoading, error } = useFeatureFlag('NEW_PAYMENT_FLOW');
+  
+  // Simple boolean check
+  const isGoogleAuthEnabled = useFeatureFlagEnabled('AUTH_GOOGLE');
+  
+  if (isLoading) return <Spinner />;
+  
+  return (
+    <div>
+      {value && <NewPaymentFlow />}
+      {isGoogleAuthEnabled && <GoogleSignInButton />}
+    </div>
+  );
+}
+```
+
+### Frontend Integration (Vanilla JavaScript)
+
+```typescript
+import { MemoryFeatureFlagProvider } from '@plyaz/core/domain';
+import { FEATURES } from '@plyaz/config';
+
+// Initialize provider
+const provider = new MemoryFeatureFlagProvider({
+  provider: 'memory',
+  isCacheEnabled: true
+}, FEATURES);
+
+await provider.initialize();
+
+// Check feature flags
+async function renderPaymentButton() {
+  const isEnabled = await provider.isEnabled('NEW_PAYMENT_FLOW', {
+    userId: getCurrentUserId(),
+    environment: 'production'
+  });
+  
+  if (isEnabled) {
+    document.getElementById('payment-btn').innerHTML = 'New Payment';
+  } else {
+    document.getElementById('payment-btn').innerHTML = 'Legacy Payment';
+  }
+}
+
+// Subscribe to changes
+provider.subscribe(() => {
+  renderPaymentButton();
+});
+```
+
+### Testing Support
+
+```typescript
+import { MemoryFeatureFlagProvider } from '@plyaz/core/domain';
+import { FEATURES } from '@plyaz/config';
+
+// Initialize for testing with overrides
+const testProvider = new MemoryFeatureFlagProvider({
+  provider: 'memory',
+  isLoggingEnabled: false
+}, FEATURES);
+
+await testProvider.initialize();
+
+// Override specific flags for testing
+testProvider.setOverride('NEW_PAYMENT_FLOW', true);
+testProvider.setOverride('BETA_FEATURE', false);
+
+// Use in tests
+describe('Payment Flow', () => {
+  it('should use new payment flow when enabled', async () => {
+    const isEnabled = await testProvider.isEnabled('NEW_PAYMENT_FLOW');
+    expect(isEnabled).toBe(true);
+  });
+});
+```
+
+## 🗄️ Cache System
+
+The cache system provides intelligent caching strategies for business logic coordination:
+
+### Basic Usage
+
+```typescript
+import { CacheManager } from '@plyaz/core/cache';
+
+// Initialize with memory strategy
+const cache = new CacheManager({
+  isEnabled: true,
+  ttl: 300, // 5 minutes
+  strategy: 'memory',
+  memoryConfig: {
+    maxSize: 1000,
+    cleanupInterval: 60000 // 1 minute
+  }
+});
+
+// Store data
+await cache.set('user:123', userData, 600); // Custom TTL of 10 minutes
+
+// Retrieve data
+const user = await cache.get<User>('user:123');
+
+// Check existence
+const exists = await cache.has('user:123');
+
+// Remove specific key
+await cache.delete('user:123');
+
+// Clear all cache
+await cache.clear();
+
+// Get cache statistics
+const stats = await cache.getStats();
+console.log(`Cache hit ratio: ${stats.hitRatio}`);
+```
+
+### Redis Strategy
+
+```typescript
+import { CacheManager } from '@plyaz/core/cache';
+
+const cache = new CacheManager({
+  isEnabled: true,
+  ttl: 300,
+  strategy: 'redis',
+  redisConfig: {
+    url: 'redis://localhost:6379',
+    keyPrefix: 'myapp:',
+    db: 0
+  }
+});
+```
+
+### Integration with Feature Flags
+
+```typescript
+// Feature flags use the cache system internally
+const provider = new MemoryFeatureFlagProvider({
+  provider: 'memory',
+  isCacheEnabled: true,  // Enables caching
+  cacheTtl: 300          // Cache TTL in seconds
+}, FEATURES);
+
+// The provider automatically caches evaluations for performance
+```
+
+### Business Logic Caching Patterns
+
+```typescript
+import { CacheManager } from '@plyaz/core/cache';
+
+class UserService {
+  constructor(private cache: CacheManager) {}
+
+  async getUser(userId: string): Promise<User> {
+    // Try cache first
+    const cacheKey = `user:${userId}`;
+    const cached = await this.cache.get<User>(cacheKey);
+    
+    if (cached) {
+      return cached;
+    }
+
+    // Fetch from database
+    const user = await this.fetchUserFromDb(userId);
+    
+    // Cache for future requests
+    await this.cache.set(cacheKey, user, 600); // 10 minutes
+    
+    return user;
+  }
+
+  async invalidateUser(userId: string): Promise<void> {
+    await this.cache.delete(`user:${userId}`);
+  }
+}
+```
+
+## 🔧 Key Features
+
+- **Environment Isolation**: Complete separation of frontend and backend code
+- **Business Caching**: Intelligent caching strategies for cross-package data coordination
+- **Feature Flags**: Complete feature flag system with multiple providers
+- **Domain-Driven Design**: Clear bounded contexts for different business domains
+- **SDK Ready**: B2B partner integration capabilities
+- **Type Safe**: Full TypeScript support across all environments
+
+## 🏛️ Microservice Strategy
+
+Install `@plyaz/core` into individual microservices and import only needed functionality:
+
+```typescript
+// User Service - only imports user-related functionality
+import { UserDomainService, UserCacheService } from '@plyaz/core/domain';
+
+// Asset Service - only imports asset-related functionality  
+import { AssetDomainService, CalculationEngine } from '@plyaz/core';
+```
+
+## 📚 Documentation
+
+For detailed architecture information, implementation guides, and examples:
+
+**[📖 Full Documentation](https://plyaz.atlassian.net/wiki/spaces/SD/pages/37257227/Core+Package?atlOrigin=eyJpIjoiNmQxZmNhYTllYmZjNDU2Njk0YmRhYWI2M2JkNTA3NDMiLCJwIjoiYyJ9)**
+
+## 🔗 Related Packages
+
+| Package | Purpose | Core Usage |
+|---------|---------|------------|
+| `@plyaz/api` | HTTP/REST API calls | Business data operations |
+| `@plyaz/web3` | Blockchain interactions | Asset operations, smart contracts |
+| `@plyaz/auth` | Authentication & authorization | User validation, permissions |
+| `@plyaz/config` | Configuration & feature flags | Business rules, environment settings |
+| `@plyaz/monitoring` | Metrics & performance tracking | Business KPI tracking |
+| `@plyaz/logger` | Logging infrastructure | Business operation logging |
+| `@plyaz/events` | Event-driven communication | Business event coordination |
+
+## 🛡️ Security & Performance
+
+- **Authentication Integration**: Built-in security via `@plyaz/auth`
+- **Input Validation**: Comprehensive validation using `@plyaz/errors`
+- **Audit Logging**: Full audit trail via `@plyaz/logger`
+- **Intelligent Caching**: Business-aware caching strategies
+- **Tree Shaking**: Environment-specific code loading
+
+## 🏗️ Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Development with watch mode
+pnpm dev
+
+# Build package
+pnpm build
+
+# Testing
+pnpm test                # Run tests once
+pnpm test:watch         # Run tests in watch mode
+pnpm test:coverage      # Run tests with coverage
+pnpm test:ui            # Run tests with UI
+
+# Code quality
+pnpm lint               # Lint code
+pnpm lint:fix           # Lint and fix issues
+pnpm format             # Format code
+pnpm format:check       # Check formatting
+pnpm type:check         # Type checking
+
+# Security
+pnpm security:check     # Run security audit
+pnpm audit:fix          # Fix security issues
+
+# Clean build artifacts
+pnpm clean
+```
+
+### TypeScript Path Aliases
+
+The package uses TypeScript path aliases for cleaner imports:
+
+**Before:**
+```typescript
+import { CacheManager } from '../../cache';
+import { FeatureFlagEngine } from '../../../engine/featureFlags/engine';
+```
+
+**After:**
+```typescript
+import { CacheManager } from '@cache/index';
+import { FeatureFlagEngine } from '@engine/featureFlags/engine';
+```
+
+**Available aliases:**
+- `@/*` → `src/*`
+- `@domain/*` → `src/domain/*`
+- `@engine/*` → `src/engine/*`
+- `@backend/*` → `src/backend/*`
+- `@frontend/*` → `src/frontend/*`
+- `@cache/*` → `src/cache/*`
+- `@utils/*` → `src/utils/*`
+- `@tests/*` → `tests/*`
+
+**Important:** When importing from index files, always specify `/index` explicitly (e.g., `@cache/index` not `@cache`).
+
+---
+
+**Note**: This package is part of the Plyaz monorepo architecture. See the [full documentation](https://plyaz.atlassian.net/wiki/spaces/SD/pages/37257227/Core+Package) for complete implementation details and architectural decisions.

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

@@ -0,0 +1,135 @@
+/**
+ * Feature Flag Controller
+ *
+ * NestJS controller for feature flag management.
+ * Provides REST API endpoints for feature flag operations.
+ *
+ * @fileoverview NestJS controller for feature flags
+ * @version 1.0.0
+ */
+import type { FeatureFlagValue, FeatureFlagContext, FeatureFlagEvaluation, FeatureFlag, FeatureFlagRule } from '@plyaz/types';
+import type { FeatureFlagService } from './feature-flag.service';
+import type { FeatureFlagKey } from '@domain/types';
+/**
+ * Request DTO for flag evaluation.
+ */
+interface EvaluateFlagRequest {
+    context?: FeatureFlagContext;
+}
+/**
+ * Request DTO for creating/updating flags.
+ */
+interface CreateFlagRequest {
+    name: string;
+    description?: string;
+    value: FeatureFlagValue;
+    isEnabled?: boolean;
+    environment?: 'all' | 'development' | 'staging' | 'production';
+    rolloutPercentage?: number;
+}
+/**
+ * Feature Flag Controller
+ *
+ * Provides REST endpoints for feature flag management and evaluation.
+ *
+ * @example
+ * ```typescript
+ * // GET /feature-flags/AUTH_GOOGLE/evaluate
+ * // POST /feature-flags
+ * // PUT /feature-flags/AUTH_GOOGLE
+ * ```
+ */
+export declare class FeatureFlagController {
+    private readonly featureFlagService;
+    constructor(featureFlagService: FeatureFlagService);
+    /**
+     * Evaluates a feature flag for the given context.
+     *
+     * @param key - Feature flag key
+     * @param body - Evaluation context
+     * @returns Feature flag evaluation result
+     */
+    evaluateFlag(key: FeatureFlagKey, body?: EvaluateFlagRequest): Promise<FeatureFlagEvaluation<FeatureFlagKey>>;
+    /**
+     * Checks if a feature flag is enabled.
+     *
+     * @param key - Feature flag key
+     * @param body - Evaluation context
+     * @returns Boolean indicating if flag is enabled
+     */
+    isEnabled(key: FeatureFlagKey, body?: EvaluateFlagRequest): Promise<{
+        isEnabled: boolean;
+    }>;
+    /**
+     * Gets all feature flags with their evaluations.
+     *
+     * @param body - Evaluation context
+     * @returns All feature flag evaluations
+     */
+    evaluateAllFlags(body?: EvaluateFlagRequest): Promise<Record<string, FeatureFlagEvaluation<FeatureFlagKey>>>;
+    /**
+     * Creates a new feature flag.
+     *
+     * @param key - Feature flag key
+     * @param createData - Flag creation data
+     * @returns Created feature flag
+     */
+    createFlag(createData: CreateFlagRequest & {
+        key: FeatureFlagKey;
+    }): Promise<FeatureFlag<FeatureFlagKey>>;
+    /**
+     * Updates an existing feature flag.
+     *
+     * @param key - Feature flag key
+     * @param updateData - Flag update data
+     * @returns Updated feature flag
+     */
+    updateFlag(key: FeatureFlagKey, updateData: Partial<CreateFlagRequest>): Promise<FeatureFlag<FeatureFlagKey>>;
+    /**
+     * Deletes a feature flag.
+     *
+     * @param key - Feature flag key
+     */
+    deleteFlag(key: FeatureFlagKey): Promise<{
+        isSuccessful: boolean;
+    }>;
+    /**
+     * Sets a manual override for a flag.
+     *
+     * @param key - Feature flag key
+     * @param value - Override value
+     */
+    setOverride(key: FeatureFlagKey, value: FeatureFlagValue): Promise<{
+        isSuccessful: boolean;
+    }>;
+    /**
+     * Removes a manual override for a flag.
+     *
+     * @param key - Feature flag key
+     */
+    removeOverride(key: FeatureFlagKey): Promise<{
+        isSuccessful: boolean;
+    }>;
+    /**
+     * Gets all available feature flags.
+     *
+     * @param environment - Filter by environment
+     * @returns List of feature flags
+     */
+    getAllFeatureFlags(environment?: string): Promise<FeatureFlag<FeatureFlagKey>[]>;
+    /**
+     * Gets all rules for a specific flag.
+     *
+     * @param key - Feature flag key
+     * @returns List of rules for the flag
+     */
+    getFlagRules(key: FeatureFlagKey): Promise<FeatureFlagRule<FeatureFlagKey>[]>;
+    /**
+     * Forces a refresh of the feature flag cache.
+     */
+    refreshCache(): Promise<{
+        isSuccessful: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=feature-flag.controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.controller.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAcH,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,eAAe,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,KAAK,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;IAC/D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBACa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,kBAAkB;IAEnE;;;;;;OAMG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;IAWjD;;;;;;OAMG;IAEG,SAAS,CACC,GAAG,EAAE,cAAc,EACzB,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAYlC;;;;;OAKG;IAEG,gBAAgB,CACZ,IAAI,GAAE,mBAAwB,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC;IAWjE;;;;;;OAMG;IAEG,UAAU,CACN,UAAU,EAAE,iBAAiB,GAAG;QAAE,GAAG,EAAE,cAAc,CAAA;KAAE,GAC9D,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAWvC;;;;;;OAMG;IAEG,UAAU,CACA,GAAG,EAAE,cAAc,EACzB,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAC7C,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAWvC;;;;OAIG;IAEG,UAAU,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAYvF;;;;;OAKG;IAEG,WAAW,CACD,GAAG,EAAE,cAAc,EAClB,KAAK,EAAE,gBAAgB,GACrC,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAYrC;;;;OAIG;IAEG,cAAc,CAAe,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAY3F;;;;;OAKG;IAEG,kBAAkB,CACA,WAAW,CAAC,EAAE,MAAM,GACzC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;IAWzC;;;;;OAKG;IAEG,YAAY,CACF,GAAG,EAAE,cAAc,GAChC,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,CAAC;IAW7C;;OAEG;IAEG,YAAY,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;CAWzD"}

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

@@ -0,0 +1,114 @@
+/**
+ * Feature Flag Module
+ *
+ * NestJS module for feature flag functionality.
+ * Configures providers, controllers, and dependencies.
+ *
+ * @fileoverview NestJS module for feature flags
+ * @version 1.0.0
+ */
+/**
+ * Feature Flag Module
+ *
+ * Provides feature flag functionality as a NestJS module.
+ * Can be imported by other modules to access feature flag services.
+ *
+ * @example
+ * ```typescript
+ * // In your app.module.ts
+ * import { FeatureFlagModule } from '@plyaz/config/backend/featureFlags';
+ *
+ * @Module({
+ *   imports: [FeatureFlagModule],
+ *   // ... other module configuration
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In your service
+ * import { FeatureFlagService } from '@plyaz/config/backend/featureFlags';
+ *
+ * @Injectable()
+ * export class MyService {
+ *   constructor(private readonly featureFlagService: FeatureFlagService) {}
+ *
+ *   async doSomething() {
+ *     const isEnabled = await this.featureFlagService.isEnabled('MY_FEATURE');
+ *     if (isEnabled) {
+ *       // Execute new feature logic
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class FeatureFlagModule {
+    /**
+     * Static method for importing the module with configuration.
+     * This allows customization of the feature flag system.
+     *
+     * @param options - Module configuration options
+     * @returns Configured module
+     *
+     * @example
+     * ```typescript
+     * @Module({
+     *   imports: [
+     *     FeatureFlagModule.forRoot({
+     *       provider: 'redis',
+     *       cacheEnabled: true,
+     *       cacheTtl: 600,
+     *     })
+     *   ],
+     * })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(options?: {
+        provider?: 'memory' | 'database' | 'redis' | 'api' | 'file';
+        isCacheEnabled?: boolean;
+        cacheTtl?: number;
+        refreshInterval?: number;
+        isLoggingEnabled?: boolean;
+    }): {
+        module: typeof FeatureFlagModule;
+        providers: unknown[];
+        exports: unknown[];
+    };
+    /**
+     * Static method for importing the module asynchronously.
+     * Useful when configuration depends on other services.
+     *
+     * @param options - Async module configuration options
+     * @returns Configured async module
+     *
+     * @example
+     * ```typescript
+     * @Module({
+     *   imports: [
+     *     FeatureFlagModule.forRootAsync({
+     *       imports: [ConfigModule],
+     *       inject: [ConfigService],
+     *       useFactory: (configService: ConfigService) => ({
+     *         provider: configService.get('FEATURE_FLAG_PROVIDER'),
+     *         cacheEnabled: configService.get('FEATURE_FLAG_CACHE_ENABLED'),
+     *       }),
+     *     })
+     *   ],
+     * })
+     * export class AppModule {}
+     * ```
+     */
+    static forRootAsync(options: {
+        imports?: unknown[];
+        inject?: unknown[];
+        useFactory?: (...args: unknown[]) => unknown;
+    }): {
+        module: typeof FeatureFlagModule;
+        imports: unknown[];
+        providers: unknown[];
+        exports: unknown[];
+    };
+}
+//# sourceMappingURL=feature-flag.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag.module.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAMa,iBAAiB;IAC5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;QACvB,QAAQ,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;QAC5D,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,GAAG;QACF,MAAM,EAAE,OAAO,iBAAiB,CAAC;QACjC,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;IAiBD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;KAC9C,GAAG;QACF,MAAM,EAAE,OAAO,iBAAiB,CAAC;QACjC,OAAO,EAAE,OAAO,EAAE,CAAC;QACnB,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;CAgBF"}