@plyaz/types 1.4.1 → 1.5.0

package/dist/testing/features/cache/types.d.ts

@@ -1,4 +1,4 @@
-import type { CacheStrategy } from '../../../features';
+import type { CacheEntry, CacheStats, CacheStrategy } from '../../../features';
 /**
  * Configuration for cache strategy test suite
  *
@@ -41,3 +41,131 @@ export interface CacheStrategyTestConfig {
     supportsStats?: boolean;
     cleanup?: (strategy: CacheStrategy) => Promise<void>;
 }
+/**
+ * Cache interface for testing
+ * @interface Cache
+ * @typeParam T - Type of cached values
+ */
+export interface Cache<T = unknown> {
+    /** Get value from cache */
+    get(key: string): Promise<T | null>;
+    /** Set value in cache */
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    /** Delete value from cache */
+    delete(key: string): Promise<boolean>;
+    /** Clear all cache entries */
+    clear(): Promise<void>;
+    /** Get cache size */
+    size(): Promise<number>;
+    /** Get cache statistics */
+    getStats?(): CacheStats;
+    /** Get raw cache entry */
+    getRaw?(key: string): Promise<CacheEntry<T> | null>;
+    /** Set eviction callback */
+    onEviction?(callback: (key: string, value: T) => void): void;
+    /** Restore cache state (internal) */
+    __restore?: () => void;
+}
+/**
+ * Cache eviction configuration
+ * @interface EvictionConfig
+ */
+export interface EvictionConfig {
+    /** Maximum cache size */
+    maxSize: number;
+    /** Eviction policy */
+    evictionPolicy: 'LRU' | 'LFU' | 'FIFO';
+    /** Number of items to add */
+    itemsToAdd: number;
+    /** Expected evicted keys */
+    expectedEvictions: string[];
+}
+/**
+ * Cache concurrency testing options
+ * @interface ConcurrencyOptions
+ */
+export interface ConcurrencyOptions {
+    /** Number of operations */
+    operations: number;
+    /** Concurrency level */
+    concurrency: number;
+    /** Type of operations */
+    operationType: 'read' | 'write' | 'mixed';
+}
+/**
+ * TTL testing options
+ * @interface TTLOptions
+ */
+export interface TTLOptions {
+    /** Cache key */
+    key: string;
+    /** Cache value */
+    value: unknown;
+    /** Time to live */
+    ttl: number;
+    /** Check intervals */
+    checkIntervals: number[];
+}
+/**
+ * TTL test result
+ * @interface TTLResult
+ */
+export interface TTLResult {
+    /** Cache key */
+    key: string;
+    /** TTL value */
+    ttl: number;
+    /** Actual expiration time */
+    actualExpiration: number;
+    /** Expected expiration time */
+    expectedExpiration: number;
+    /** Whether within tolerance */
+    withinTolerance: boolean;
+}
+/**
+ * Memory usage testing options
+ * @interface MemoryOptions
+ */
+export interface MemoryOptions {
+    /** Sample size for testing */
+    sampleSize: number;
+    /** Maximum memory limit in MB */
+    maxMemoryMB?: number;
+}
+/**
+ * Memory usage test result
+ * @interface MemoryResult
+ */
+export interface MemoryResult {
+    /** Total memory usage in MB */
+    totalMemoryMB: number;
+    /** Average item size in KB */
+    avgItemSizeKB: number;
+    /** Number of items */
+    itemCount: number;
+    /** Whether within memory limit */
+    withinLimit: boolean;
+}
+/**
+ * Cache test harness
+ * @interface CacheTestHarness
+ * @typeParam T - Type of cached values
+ */
+export interface CacheTestHarness<T = unknown> {
+    /** Cache instance */
+    cache: Cache<T>;
+    /** Fill cache with entries */
+    fillCache: (entries: Array<{
+        key: string;
+        value: T;
+    }>) => Promise<void>;
+    /** Measure cache performance */
+    measurePerformance: (operations: number) => Promise<{
+        avgReadMs: number;
+        avgWriteMs: number;
+    }>;
+    /** Simulate concurrent access */
+    simulateConcurrentAccess: (options: ConcurrencyOptions) => Promise<void>;
+    /** Reset cache state */
+    reset: () => Promise<void>;
+}

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

@@ -99,7 +99,7 @@ export interface SetupFeatureFlagModuleMocks {
     /** Mock logger instance */
     mockLogger: MockLogger;
     /** Mock HTTP exception constructor */
-    HttpException: Vitest.Mock;
+    HttpException: Vitest.MockInstance;
     /** HTTP status code constants */
     HttpStatus: Record<string, number>;
 }
@@ -250,25 +250,25 @@ export interface FeatureFlagScenarios<FeatureFlagKey extends string> {
  */
 export interface MockFeatureFlagProvider {
     /** Get a specific feature flag */
-    getFlag: Vitest.Mock;
+    getFlag: Vitest.MockInstance;
     /** Get all feature flags */
-    getAllFlags: Vitest.Mock;
+    getAllFlags: Vitest.MockInstance;
     /** Evaluate a feature flag */
-    evaluateFlag: Vitest.Mock;
+    evaluateFlag: Vitest.MockInstance;
     /** Check if a flag is enabled */
-    isEnabled: Vitest.Mock;
+    isEnabled: Vitest.MockInstance;
     /** Get a flag's value */
-    getValue: Vitest.Mock;
+    getValue: Vitest.MockInstance;
     /** Update a feature flag */
-    updateFlag: Vitest.Mock;
+    updateFlag: Vitest.MockInstance;
     /** Delete a feature flag */
-    deleteFlag: Vitest.Mock;
+    deleteFlag: Vitest.MockInstance;
     /** Refresh flag data */
-    refresh: Vitest.Mock;
+    refresh: Vitest.MockInstance;
     /** Subscribe to flag changes */
-    subscribe: Vitest.Mock;
+    subscribe: Vitest.MockInstance;
     /** Unsubscribe from flag changes */
-    unsubscribe: Vitest.Mock;
+    unsubscribe: Vitest.MockInstance;
 }
 /**
  * Mock feature flag repository interface for database operations testing
@@ -289,21 +289,21 @@ export interface MockFeatureFlagProvider {
  */
 export interface MockFeatureFlagRepository {
     /** Find a single flag by criteria */
-    find: Vitest.Mock;
+    find: Vitest.MockInstance;
     /** Find all flags */
-    findAll: Vitest.Mock;
+    findAll: Vitest.MockInstance;
     /** Create a new flag */
-    create: Vitest.Mock;
+    create: Vitest.MockInstance;
     /** Update an existing flag */
-    update: Vitest.Mock;
+    update: Vitest.MockInstance;
     /** Delete a flag */
-    delete: Vitest.Mock;
+    delete: Vitest.MockInstance;
     /** Save a flag */
-    save: Vitest.Mock;
+    save: Vitest.MockInstance;
     /** Check if a flag exists */
-    exists: Vitest.Mock;
+    exists: Vitest.MockInstance;
     /** Count total flags */
-    count: Vitest.Mock;
+    count: Vitest.MockInstance;
 }
 /**
  * Mock feature flag service interface for business logic testing
@@ -324,21 +324,21 @@ export interface MockFeatureFlagRepository {
  */
 export interface MockFeatureFlagService {
     /** Evaluate a single flag */
-    evaluate: Vitest.Mock;
+    evaluate: Vitest.MockInstance;
     /** Evaluate all flags */
-    evaluateAll: Vitest.Mock;
+    evaluateAll: Vitest.MockInstance;
     /** Check if flag is enabled */
-    isEnabled: Vitest.Mock;
+    isEnabled: Vitest.MockInstance;
     /** Get flag value */
-    getValue: Vitest.Mock;
+    getValue: Vitest.MockInstance;
     /** Get flag variation */
-    getVariation: Vitest.Mock;
+    getVariation: Vitest.MockInstance;
     /** Track flag usage */
-    track: Vitest.Mock;
+    track: Vitest.MockInstance;
     /** Refresh flag data */
-    refresh: Vitest.Mock;
+    refresh: Vitest.MockInstance;
     /** Clear cache */
-    invalidateCache: Vitest.Mock;
+    invalidateCache: Vitest.MockInstance;
 }
 /**
  * Mock feature flag evaluation engine interface for testing flag logic
@@ -356,15 +356,15 @@ export interface MockFeatureFlagService {
  */
 export interface MockFeatureFlagEngine {
     /** Evaluate flag with context */
-    evaluate: Vitest.Mock;
+    evaluate: Vitest.MockInstance;
     /** Evaluate conditions */
-    evaluateConditions: Vitest.Mock;
+    evaluateConditions: Vitest.MockInstance;
     /** Check rollout eligibility */
-    checkRollout: Vitest.Mock;
+    checkRollout: Vitest.MockInstance;
     /** Calculate variation */
-    calculateVariation: Vitest.Mock;
+    calculateVariation: Vitest.MockInstance;
     /** Get default value */
-    getDefaultValue: Vitest.Mock;
+    getDefaultValue: Vitest.MockInstance;
 }
 /**
  * Mock feature flag cache interface for testing caching behavior
@@ -385,21 +385,21 @@ export interface MockFeatureFlagEngine {
  */
 export interface MockFeatureFlagCache {
     /** Get cached value */
-    get: Vitest.Mock;
+    get: Vitest.MockInstance;
     /** Set cache value */
-    set: Vitest.Mock;
+    set: Vitest.MockInstance;
     /** Delete cached value */
-    delete: Vitest.Mock;
+    delete: Vitest.MockInstance;
     /** Clear all cache */
-    clear: Vitest.Mock;
+    clear: Vitest.MockInstance;
     /** Check if key exists */
-    has: Vitest.Mock;
+    has: Vitest.MockInstance;
     /** Get all cache keys */
-    keys: Vitest.Mock;
+    keys: Vitest.MockInstance;
     /** Get all cache values */
-    values: Vitest.Mock;
+    values: Vitest.MockInstance;
     /** Get cache size */
-    size: Vitest.Mock;
+    size: Vitest.MockInstance;
 }
 /**
  * Test context for feature flag testing with React components
@@ -1076,7 +1076,7 @@ export interface SubscriptionFeatureFlagTracker<FeatureFlagKey extends string> {
     /** Track a new subscription */
     track: (provider: IFeatureFlagProvider<FeatureFlagKey>, id?: string) => {
         id: string;
-        callback: Vitest.Mock;
+        callback: Vitest.MockInstance;
         unsubscribe: () => void;
     };
     /** Unsubscribe by ID */
@@ -1369,3 +1369,165 @@ export interface FileProviderTestScenario<FeatureFlagKey extends string> extends
     /** Wait for file system changes to propagate */
     waitForFileChange: (ms?: number) => Promise<void>;
 }
+/**
+ * Feature flag service interface for NestJS
+ * @interface FeatureFlagService
+ */
+export interface FeatureFlagService {
+    /** Logger instance */
+    logger: unknown;
+    /** Feature flag provider */
+    provider: unknown;
+    /** Check if feature is enabled */
+    isEnabled: (key: string, context?: Record<string, unknown>) => Promise<boolean>;
+    /** Get feature value */
+    getValue: <T>(key: string, defaultValue: T, context?: Record<string, unknown>) => Promise<T>;
+    /** Get all features */
+    getAll: () => Promise<Record<string, unknown>>;
+    /** Refresh feature flags */
+    refresh: () => Promise<void>;
+}
+/**
+ * Feature flag repository interface for NestJS
+ * @interface FeatureFlagRepository
+ * @typeParam FeatureFlagKey - Type of feature flag keys
+ */
+export interface FeatureFlagRepository<FeatureFlagKey extends string> {
+    /** Logger instance */
+    logger: unknown;
+    /** Find feature flag by key */
+    findByKey: (key: FeatureFlagKey) => Promise<unknown>;
+    /** Create new feature flag */
+    create: (key: FeatureFlagKey, data: unknown) => Promise<unknown>;
+    /** Update feature flag */
+    update: (key: FeatureFlagKey, data: unknown) => Promise<unknown>;
+    /** Delete feature flag */
+    delete: (key: FeatureFlagKey) => Promise<void>;
+    /** Find all feature flags */
+    findAll: () => Promise<Array<{
+        key: FeatureFlagKey;
+        data: unknown;
+    }>>;
+}
+/**
+ * Rollout configuration for testing
+ * @interface RolloutConfig
+ * @typeParam T - Type of feature flag keys
+ */
+export interface RolloutConfig<T extends string> {
+    /** Feature flag key */
+    flagKey: T;
+    /** Starting rollout percentage */
+    startPercentage: number;
+    /** Ending rollout percentage */
+    endPercentage: number;
+    /** Duration of rollout */
+    duration: number;
+}
+/**
+ * Rollout scenario for testing
+ * @interface RolloutScenario
+ * @typeParam T - Type of feature flag keys
+ */
+export interface RolloutScenario<T extends string> {
+    /** Rollout configuration */
+    config: RolloutConfig<T>;
+    /** Get current percentage */
+    getCurrentPercentage: () => number;
+    /** Update percentage */
+    updatePercentage: (percentage: number) => void;
+    /** Check if flag is enabled for user */
+    isEnabledForUser: (userId: string) => boolean;
+}
+/**
+ * A/B test configuration
+ * @interface ABTestConfig
+ * @typeParam T - Type of feature flag keys
+ */
+export interface ABTestConfig<T extends string> {
+    /** Feature flag key */
+    flagKey: T;
+    /** Test variants */
+    variants: {
+        /** Variant A configuration */
+        A: {
+            /** Variant percentage */
+            percentage: number;
+            /** Variant value */
+            value: FeatureFlagValue;
+        };
+        /** Variant B configuration */
+        B: {
+            /** Variant percentage */
+            percentage: number;
+            /** Variant value */
+            value: FeatureFlagValue;
+        };
+    };
+    /** Test duration */
+    duration?: number;
+    /** Target audience */
+    audience?: {
+        /** Include criteria */
+        include?: string[];
+        /** Exclude criteria */
+        exclude?: string[];
+    };
+}
+/**
+ * A/B test scenario for testing
+ * @interface ABTestScenario
+ * @typeParam T - Type of feature flag keys
+ */
+export interface CreateABTestScenario<T extends string> {
+    /** A/B test configuration */
+    config: ABTestConfig<T>;
+    /** Get variant for user */
+    getVariantForUser: (userId: string, attributes?: Record<string, unknown>) => FeatureFlagValue;
+    /** Get variant statistics */
+    getVariantStats: () => {
+        /** Variant A statistics */
+        A: {
+            count: number;
+            percentage: number;
+        };
+        /** Variant B statistics */
+        B: {
+            count: number;
+            percentage: number;
+        };
+    };
+    /** Reset test state */
+    reset: () => void;
+}
+/**
+ * Flag defaults interface
+ * @interface FlagDefaults
+ */
+export interface FlagDefaults {
+    /** Flag name */
+    name: string;
+    /** Flag description */
+    description: string;
+    /** Whether flag is enabled */
+    isEnabled: boolean;
+    /** Default value */
+    value: FeatureFlagValue;
+    /** Flag type */
+    type: FlagType;
+    /** Environment */
+    environment: 'development' | 'staging' | 'production' | 'all';
+    /** Created date */
+    createdAt: Date;
+    /** Updated date */
+    updatedAt: Date;
+    /** Created by */
+    createdBy: string;
+    /** Updated by */
+    updatedBy: string;
+}
+/**
+ * Feature flag value type
+ * @type FlagType
+ */
+export type FlagType = 'boolean' | 'string' | 'number' | 'json';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plyaz/types",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "author": "Redeemer Pace",
   "license": "ISC",
   "description": "Provides shared TypeScript types and schema utilities for validation and parsing in the @playz ecosystem.",