@plyaz/core 1.2.0 → 1.3.0

package/dist/services/CacheService.d.ts

@@ -0,0 +1,176 @@
+/**
+ * CacheService - Singleton Cache Manager
+ *
+ * @description Manages cache instance for the entire application using a singleton pattern.
+ * This service wraps the CacheManager from @plyaz/core/base/cache and provides a centralized
+ * way to initialize and access caching across all backend services.
+ *
+ * **Architecture:**
+ * - Supports multiple strategies: Memory (in-process), Redis (distributed)
+ * - Configurable TTL, key prefixing, and strategy-specific options
+ * - Singleton pattern ensures single cache instance across application
+ *
+ * **Strategy Configuration:**
+ * - **Memory**: In-process LRU cache, no external dependencies
+ * - **Redis**: Distributed cache using ioredis, requires Redis server
+ *
+ * **Required Environment Variables (Redis):**
+ * - REDIS_URL: Redis connection string (e.g., redis://localhost:6379)
+ * - Or REDIS_HOST, REDIS_PORT, REDIS_PASSWORD for individual config
+ *
+ * @example Using with Core.initialize() (Recommended)
+ * ```typescript
+ * import { Core } from '@plyaz/core';
+ *
+ * await Core.initialize({
+ *   envPath: '.env',
+ *   cache: {
+ *     strategy: 'memory',
+ *     isEnabled: true,
+ *     ttl: 300, // 5 minutes default
+ *   },
+ * });
+ *
+ * // Access via Core.cache
+ * const cache = Core.cache.getCacheManager();
+ * await cache.set('user:123', userData, 600); // 10 minutes TTL
+ * const cached = await cache.get('user:123');
+ * ```
+ *
+ * @example With Redis Strategy
+ * ```typescript
+ * await Core.initialize({
+ *   envPath: '.env',
+ *   cache: {
+ *     strategy: 'redis',
+ *     isEnabled: true,
+ *     ttl: 300,
+ *     prefix: 'myapp',
+ *     redis: {
+ *       url: process.env.REDIS_URL,
+ *       // Or individual options:
+ *       // host: process.env.REDIS_HOST,
+ *       // port: parseInt(process.env.REDIS_PORT),
+ *       // password: process.env.REDIS_PASSWORD,
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @example Direct Usage
+ * ```typescript
+ * import { CacheService } from '@plyaz/core/services';
+ *
+ * await CacheService.initialize({
+ *   strategy: 'memory',
+ *   isEnabled: true,
+ *   ttl: 300,
+ * });
+ *
+ * const cache = CacheService.getInstance().getCacheManager();
+ * await cache.set('key', value);
+ * ```
+ *
+ * @example Skip Cache (Disable Caching)
+ * ```typescript
+ * await Core.initialize({
+ *   skipCache: true, // Cache will not be initialized
+ * });
+ * ```
+ *
+ * @fileoverview Cache service singleton
+ * @module services/CacheService
+ */
+import { CacheManager } from '../base/cache';
+import type { CoreCacheConfig } from '@plyaz/types/core';
+/**
+ * Singleton service for managing application-wide cache
+ *
+ * Provides centralized access to cache functionality across all backend services.
+ * Automatically integrates with BaseBackendDomainService when initialized.
+ */
+export declare class CacheService {
+    /** Singleton instance */
+    private static instance;
+    /** Cache manager instance */
+    private cacheManager;
+    /** Configuration used to initialize cache */
+    private config;
+    /** Logger instance */
+    private logger;
+    /** Private constructor to enforce singleton */
+    private constructor();
+    /**
+     * Initialize the cache service with configuration
+     *
+     * @param config - Cache configuration
+     * @throws {CorePackageError} If already initialized or config is invalid
+     *
+     * @example
+     * ```typescript
+     * await CacheService.initialize({
+     *   strategy: 'redis',
+     *   isEnabled: true,
+     *   ttl: 300,
+     *   prefix: 'app',
+     *   redis: { url: process.env.REDIS_URL },
+     * });
+     * ```
+     */
+    static initialize(config: CoreCacheConfig): Promise<void>;
+    /**
+     * Get the singleton instance
+     *
+     * @throws {CorePackageError} If not initialized
+     * @returns CacheService singleton instance
+     *
+     * @example
+     * ```typescript
+     * const cacheService = CacheService.getInstance();
+     * const cache = cacheService.getCacheManager();
+     * ```
+     */
+    static getInstance(): CacheService;
+    /**
+     * Get the cache manager instance
+     *
+     * @throws {CorePackageError} If cache not initialized
+     * @returns CacheManager instance
+     *
+     * @example
+     * ```typescript
+     * const cache = CacheService.getInstance().getCacheManager();
+     * await cache.set('user:123', userData);
+     * const user = await cache.get('user:123');
+     * ```
+     */
+    getCacheManager(): CacheManager;
+    /**
+     * Get current cache configuration
+     *
+     * @returns Current cache configuration or null if not initialized
+     */
+    getConfig(): CoreCacheConfig | null;
+    /**
+     * Check if cache is initialized and enabled
+     *
+     * @returns True if cache is ready to use
+     */
+    isInitialized(): boolean;
+    /**
+     * Reset the cache service (useful for testing)
+     *
+     * @internal
+     */
+    static reset(): void;
+    /**
+     * Validate cache configuration
+     *
+     * @param config - Configuration to validate
+     * @throws {CorePackageError} If configuration is invalid
+     * @private
+     */
+    private validateConfig;
+}
+export declare const getCacheService: () => CacheService;
+//# sourceMappingURL=CacheService.d.ts.map

package/dist/services/CacheService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheService.d.ts","sourceRoot":"","sources":["../../src/services/CacheService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAMzD;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,yBAAyB;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAEpD,6BAA6B;IAC7B,OAAO,CAAC,YAAY,CAA6B;IAEjD,6CAA6C;IAC7C,OAAO,CAAC,MAAM,CAAgC;IAE9C,sBAAsB;IACtB,OAAO,CAAC,MAAM,CAA+C;IAE7D,+CAA+C;IAC/C,OAAO;IAEP;;;;;;;;;;;;;;;;OAgBG;WACU,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA0C/D;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,WAAW,IAAI,YAAY;IAUlC;;;;;;;;;;;;OAYG;IACH,eAAe,IAAI,YAAY;IAU/B;;;;OAIG;IACH,SAAS,IAAI,eAAe,GAAG,IAAI;IAInC;;;;OAIG;IACH,aAAa,IAAI,OAAO;IAIxB;;;;OAIG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;IAWpB;;;;;;OAMG;IAEH,OAAO,CAAC,cAAc;CA6BvB;AAGD,eAAO,MAAM,eAAe,QAAO,YAA0C,CAAC"}

package/dist/services/DbService.d.ts

@@ -0,0 +1,393 @@
+/**
+ * DbService - Singleton Database Connection Manager
+ *
+ * @description Manages database connections for the entire application using a singleton pattern.
+ * This service wraps @plyaz/db and provides a centralized way to initialize and access
+ * the database across all domains (feature flags, users, campaigns, backoffice, etc.).
+ *
+ * **Architecture:**
+ * - Uses `createDatabaseService()` from @plyaz/db which builds an adapter chain
+ * - Supports Drizzle (direct PostgreSQL), Supabase (REST API), or raw SQL adapters
+ * - Extension layers: Encryption → SoftDelete → Caching → Audit → ReadReplica
+ *
+ * **Adapter Configuration:**
+ * - **Drizzle**: Requires `connectionString` (PostgreSQL URL)
+ * - **Supabase**: Requires `supabaseUrl`, `supabaseServiceKey`, `supabaseAnonKey`
+ * - **SQL**: Requires `connectionString`
+ *
+ * **Required Environment Variables (Drizzle with Supabase):**
+ * - DATABASE_URL: PostgreSQL connection string (from Supabase Dashboard > Database > URI)
+ *
+ * **Required Environment Variables (Supabase REST API):**
+ * - SUPABASE_URL: Your Supabase project URL
+ * - SUPABASE_SERVICE_ROLE_KEY: Service role key for admin operations
+ * - SUPABASE_ANON_PUBLIC_KEY: Anonymous key for public operations
+ *
+ * @example Using with Core.initialize() (Recommended)
+ * ```typescript
+ * import { Core } from '@plyaz/core';
+ *
+ * // Core.initialize() handles loading env and passing to DbService
+ * await Core.initialize({
+ *   envPath: '.env',
+ *   db: {
+ *     adapter: 'sql',
+ *     cache: { enabled: true, ttl: 60 },
+ *   },
+ * });
+ *
+ * // Access via Core.db
+ * const db = Core.db.getDatabase();
+ * const result = await db.list('users', { pagination: { limit: 10, offset: 0 } });
+ * ```
+ *
+ * @example Direct Usage (requires explicit config)
+ * ```typescript
+ * // Direct usage requires explicit connectionString
+ * await DbService.initialize({
+ *   adapter: 'drizzle',
+ *   drizzle: {
+ *     connectionString: 'postgresql://user:pass@localhost:5432/db',
+ *     poolSize: 20,
+ *   },
+ * });
+ * ```
+ *
+ * @example With Extensions
+ * ```typescript
+ * await Core.initialize({
+ *   envPath: '.env',
+ *   db: {
+ *     adapter: 'drizzle',
+ *     softDelete: {
+ *       enabled: true,
+ *       field: 'deleted_at',
+ *       excludeTables: ['audit_logs', 'feature_flag_evaluations'],
+ *     },
+ *     cache: {
+ *       enabled: true,
+ *       provider: 'memory',
+ *       ttl: 300,
+ *     },
+ *     audit: {
+ *       enabled: true,
+ *       retentionDays: 90,
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @example Using with BaseRepository
+ * ```typescript
+ * import { BaseRepository } from '@plyaz/db';
+ * import { DbService } from '@plyaz/core';
+ *
+ * class UserRepository extends BaseRepository<User> {
+ *   constructor() {
+ *     super(DbService.getInstance().getDatabase(), 'users');
+ *   }
+ * }
+ * ```
+ *
+ * @module services
+ */
+import { type DatabaseServiceInterface, type Transaction } from '@plyaz/types/db';
+/**
+ * Default fields to encrypt per table
+ * Contains sensitive PII and financial data that should be encrypted at rest
+ *
+ * @see docs/db-schemas/dbdiagram_schema.dbml for field definitions
+ */
+export declare const DEFAULT_ENCRYPTION_FIELDS: Record<string, string[]>;
+export type { CoreDbServiceConfig } from '@plyaz/types/core';
+import type { CoreDbServiceConfig as DbServiceConfig } from '@plyaz/types/core';
+/**
+ * Complete table registry from database migrations
+ * Maps logical table names to their ID columns
+ *
+ * @see docs/db-schemas/migrations/ for schema definitions
+ * @see docs/db-schemas/dbdiagram_schema.dbml for full schema
+ */
+/**
+ * TABLE_REGISTRY - Custom ID Column and Schema Registry
+ *
+ * ONLY register tables with:
+ * 1. Custom ID columns (anything other than 'id')
+ * 2. Custom database schemas (anything other than 'public')
+ *
+ * Tables with standard 'id' column in 'public' schema do NOT need registration.
+ * You can also override ID column and schema per-query using OperationConfig.
+ *
+ * Schema can be defined in the table key or in the config object (or both):
+ * - 'schema.table': { idColumn: 'key' }              ← Schema in key only
+ * - 'schema.table': { idColumn: 'key', schema: 'schema' } ← Redundant but allowed
+ * - 'schema.table': {}                                ← Empty config, schema in key
+ * - 'table': { idColumn: 'key', schema: 'schema' }   ← Schema in config only
+ *
+ * @example
+ * ```typescript
+ * // Using registry
+ * await db.get('feature_flags', 'my-flag-key'); // Uses 'key' column from registry
+ *
+ * // Per-query override
+ * await db.get('custom_table', 'some-key', { idColumn: 'custom_id' });
+ *
+ * // Schema override
+ * await db.get('logs', '123', { schema: 'logging' });
+ * ```
+ */
+export declare const TABLE_REGISTRY: Record<string, {
+    idColumn?: string;
+    schema?: string;
+}>;
+/**
+ * DbService - Singleton Database Connection Manager
+ *
+ * Provides centralized database connection management for all domains.
+ * Uses @plyaz/db under the hood with configurable adapters and extensions.
+ */
+export declare class DbService {
+    private static instance;
+    private databaseService;
+    private namedAdapters;
+    private config;
+    private initialized;
+    private constructor();
+    /**
+     * Emits a database error event via CoreEventManager.
+     * Called when database operations fail to integrate with global error handling.
+     *
+     * @param error - The error that occurred
+     * @param operation - The operation that failed (e.g., 'transaction', 'query', 'healthCheck')
+     * @param table - Optional table name involved in the operation
+     * @param query - Optional query string that failed
+     * @param recoverable - Whether the error is recoverable (default: false)
+     */
+    private emitDatabaseError;
+    /**
+     * Gets the singleton instance of DbService
+     *
+     * @returns {DbService} The singleton instance
+     */
+    static getInstance(): DbService;
+    /**
+     * Checks if the database service has been initialized
+     *
+     * @returns {boolean} True if initialized
+     */
+    static isInitialized(): boolean;
+    /**
+     * Resets the database service by closing connections and clearing the singleton instance
+     *
+     * @description Properly closes the database connection and clears the singleton.
+     * Useful for testing or when you need to reinitialize with different configuration.
+     *
+     * @example
+     * ```typescript
+     * await DbService.reset();
+     * await DbService.initialize({ adapter: 'sql', ... });
+     * ```
+     */
+    static reset(): Promise<void>;
+    /**
+     * Initializes the database connection
+     *
+     * @description Sets up the database connection using the provided configuration
+     * or environment variables. This method is idempotent - calling it multiple
+     * times won't create additional connections.
+     *
+     * **Environment Variables:**
+     * - `DATABASE_URL` - PostgreSQL connection string (for sql/drizzle adapters)
+     * - `ENCRYPTION_KEY` - 32-byte encryption key for field encryption (optional)
+     * - `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY`, `SUPABASE_ANON_PUBLIC_KEY` - For supabase adapter
+     *
+     * **Encryption:** If `ENCRYPTION_KEY` env is set, encryption is auto-enabled
+     * using `DEFAULT_ENCRYPTION_FIELDS`. Override via config.encryption.
+     *
+     * @param {DbServiceConfig} [config] - Optional configuration
+     * @returns {Promise<DbService>} The initialized DbService instance
+     * @throws {DatabasePackageError} When configuration is invalid or connection fails
+     *
+     * @example
+     * ```typescript
+     * // Minimal - uses DATABASE_URL env, auto-enables encryption if ENCRYPTION_KEY set
+     * await DbService.initialize();
+     *
+     * // With explicit encryption
+     * await DbService.initialize({
+     *   adapter: 'sql',
+     *   encryption: {
+     *     enabled: true,
+     *     key: 'your-32-byte-encryption-key-here!!',
+     *     fields: DEFAULT_ENCRYPTION_FIELDS,
+     *   },
+     * });
+     *
+     * // Or via Core.initialize() with env:
+     * await Core.initialize({
+     *   env: { ENCRYPTION_KEY: '...' },
+     *   db: { adapter: 'sql' },
+     * });
+     * ```
+     */
+    /** Build encryption config from user config */
+    private static buildEncryptionConfig;
+    /** Merge user config with defaults */
+    private static mergeConfig;
+    /** Initialize named adapters */
+    private initializeNamedAdapters;
+    static initialize(config?: DbServiceConfig): Promise<DbService>;
+    /**
+     * Builds the DatabaseServiceConfig based on the adapter type
+     * @private
+     */
+    /** Builds adapter-specific config based on adapter type */
+    private buildAdapterConfig;
+    /** Builds soft delete extension config */
+    private buildSoftDeleteExtension;
+    /** Builds cache extension config */
+    private buildCacheExtension;
+    /** Builds audit extension config */
+    private buildAuditExtension;
+    /** Builds encryption extension config */
+    private buildEncryptionExtension;
+    private buildDatabaseConfig;
+    /**
+     * Builds Drizzle adapter configuration
+     * @private
+     */
+    private buildDrizzleConfig;
+    /**
+     * Builds Supabase adapter configuration
+     * @private
+     */
+    private buildSupabaseConfig;
+    /**
+     * Builds SQL adapter configuration
+     * @private
+     */
+    private buildSqlConfig;
+    /**
+     * Builds table ID column mappings from TABLE_REGISTRY
+     * @private
+     * @returns Record of table names to ID column names
+     */
+    private buildTableIdColumns;
+    /**
+     * Gets the initialized database service instance
+     *
+     * @param {string} [adapterName] - Optional named adapter to use instead of default
+     * @returns {DatabaseServiceInterface} The database service instance
+     * @throws {DatabasePackageError} When database is not initialized or named adapter not found
+     */
+    getDatabase(adapterName?: string): DatabaseServiceInterface;
+    /**
+     * Gets a named adapter by name
+     *
+     * @param {string} name - The name of the adapter
+     * @returns {DatabaseServiceInterface} The named adapter instance
+     * @throws {DatabasePackageError} When adapter not found
+     */
+    getAdapter(name: string): DatabaseServiceInterface;
+    /**
+     * Lists all available named adapters
+     *
+     * @returns {string[]} Array of adapter names
+     */
+    getAvailableAdapters(): string[];
+    /**
+     * Executes a database transaction with automatic rollback on failure
+     *
+     * @template T The return type of the transaction callback
+     * @param {Function} callback - Function that receives transaction object
+     * @returns {Promise<T>} The result of the transaction callback
+     * @throws {DatabasePackageError} When transaction fails
+     */
+    transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+    /**
+     * Sets audit context for subsequent operations
+     *
+     * @param context - Audit context (userId, requestId, etc.)
+     */
+    setAuditContext(context: {
+        userId?: string;
+        requestId?: string;
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    /**
+     * Performs a health check on the database connection
+     *
+     * @returns Health check result
+     */
+    healthCheck(): Promise<{
+        isHealthy: boolean;
+        responseTime?: number;
+        error?: string;
+    }>;
+    /**
+     * Gets the table registry with all known tables and their ID columns
+     *
+     * @returns The complete table registry
+     */
+    static getTableRegistry(): typeof TABLE_REGISTRY;
+    /**
+     * Gets ID column for a specific table
+     *
+     * @param tableName - Name of the table
+     * @returns ID column name or 'id' as default
+     */
+    static getTableIdColumn(tableName: string): string;
+    /**
+     * Reinitializes the database connection with new config
+     *
+     * @param {DbServiceConfig} [config] - New configuration
+     * @returns {Promise<DbService>} The reinitialized DbService instance
+     */
+    static reinitialize(config?: DbServiceConfig): Promise<DbService>;
+    /**
+     * Closes the database connection and cleans up resources
+     */
+    close(): Promise<void>;
+    /**
+     * Gets the current configuration
+     *
+     * @returns {DbServiceConfig | null} Current config or null if not initialized
+     */
+    getConfig(): DbServiceConfig | null;
+    /**
+     * Gets the current adapter type
+     *
+     * @returns The adapter type or null if not initialized
+     */
+    getAdapterType(): 'drizzle' | 'supabase' | 'sql' | null;
+    /**
+     * Creates a dedicated database service instance (NOT the singleton)
+     *
+     * Use this when you need an isolated database connection with its own configuration
+     * that doesn't affect or get affected by the shared singleton instance.
+     *
+     * @param config - Database service configuration
+     * @returns Promise that resolves to a new dedicated DbService instance
+     *
+     * @example
+     * ```typescript
+     * // Create a dedicated instance for analytics database
+     * const analyticsDb = await DbService.createInstance({
+     *   adapter: 'sql',
+     *   sql: { connectionString: process.env.ANALYTICS_DB_URL },
+     *   cache: { enabled: false }, // No caching for analytics
+     * });
+     *
+     * // This instance is independent from DbService.getInstance()
+     * const data = await analyticsDb.getDatabase().list('events');
+     *
+     * // Clean up when done
+     * await analyticsDb.close();
+     * ```
+     */
+    static createInstance(config: DbServiceConfig): Promise<DbService>;
+}
+/** Type alias for DbService instance (use for type-only imports to avoid bundling) */
+export type DbServiceInstance = DbService;
+//# sourceMappingURL=DbService.d.ts.map

package/dist/services/DbService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DbService.d.ts","sourceRoot":"","sources":["../../src/services/DbService.ts"],"names":[],"mappings":"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"}