@plyaz/db 0.0.0

package/dist/advanced/backup/BackupService.d.ts

@@ -0,0 +1,159 @@
+import type { BackupConfig, BackupInfo, DatabaseResult } from "@plyaz/types/db";
+/**
+ * Manages database backups with compression, encryption, and cloud storage.
+ * Provides automated scheduling and retention management.
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   connectionString: 'postgres://user:pass@localhost:5432/db',
+ *   backupDir: './backups',
+ *   retentionDays: 30,
+ *   compression: true,
+ *   encryption: {
+ *     enabled: true,
+ *     key: 'encryption-key'
+ *   },
+ *   s3: {
+ *     enabled: true,
+ *     bucket: 'my-backup-bucket',
+ *     region: 'us-east-1',
+ *     accessKey: 'aws-access-key',
+ *     secretKey: 'aws-secret-key'
+ *   }
+ * };
+ *
+ * const backupService = new BackupService(config);
+ *
+ * // Create a backup
+ * const backup = await backupService.createBackup();
+ * console.log(`Backup created: ${backup.value.filename}`);
+ *
+ * // List all backups
+ * const backups = await backupService.listBackups();
+ *
+ * // Restore from backup
+ * await backupService.restoreBackup(backup.value.id);
+ *
+ * // Clean up expired backups
+ * await backupService.cleanupExpiredBackups();
+ * ```
+ */
+export declare class BackupService {
+    private config;
+    private backups;
+    /**
+     * Creates a new BackupService instance.
+     * @param config Backup configuration
+     */
+    constructor(config: BackupConfig);
+    /**
+     * Creates a new database backup.
+     * @returns Information about the created backup
+     */
+    createBackup(): Promise<DatabaseResult<BackupInfo>>;
+    /**
+     * Restores database from a backup.
+     * @param backupId ID of the backup to restore
+     * @returns Operation result
+     */
+    restoreBackup(backupId: string): Promise<DatabaseResult<null>>;
+    /**
+     * Lists all available backups.
+     * @returns Array of backup information
+     */
+    listBackups(): Promise<DatabaseResult<BackupInfo[]>>;
+    /**
+     * Creates a scheduled backup.
+     * @returns Information about the created backup
+     */
+    scheduleBackup(): Promise<DatabaseResult<BackupInfo>>;
+    /**
+     * Removes expired backups from storage.
+     * @returns Operation result
+     */
+    cleanupExpiredBackups(): Promise<DatabaseResult<null>>;
+    /**
+     * Deletes a specific backup.
+     * @param backupId ID of the backup to delete
+     */
+    private deleteBackup;
+    /**
+     * Ensures backup directory exists.
+     */
+    private ensureBackupDir;
+    /**
+     * Loads existing backups from the backup directory.
+     */
+    private loadExistingBackups;
+    /**
+     * Generates a unique backup ID.
+     * @returns Unique backup identifier
+     */
+    private generateBackupId;
+    /**
+     * Gets file size in bytes.
+     * @param filepath Path to the file
+     * @returns File size in bytes
+     */
+    private getFileSize;
+    /**
+     * Compresses a file using gzip.
+     * @param filepath Path to the file to compress
+     */
+    private compressFile;
+    /**
+     * Decompresses a gzipped file.
+     * @param filepath Path to the gzipped file
+     */
+    private decompressFile;
+    /**
+     * Encrypts a file using OpenSSL.
+     * @param filepath Path to the file to encrypt
+     */
+    private encryptFile;
+    /**
+     * Decrypts a file using OpenSSL.
+     * @param filepath Path to the encrypted file
+     */
+    private decryptFile;
+    /**
+     * Uploads a backup to S3.
+     * @param backup Backup information
+     */
+    private uploadToS3;
+    /**
+     * Downloads a backup from S3.
+     * @param backup Backup information
+     * @returns Local path to downloaded file
+     */
+    private downloadFromS3;
+    /**
+     * Deletes a backup from S3.
+     * @param backup Backup information
+     */
+    private deleteFromS3;
+    /**
+     * Sets up scheduled backups using cron.
+     */
+    private scheduleBackups;
+    /**
+     * Validates file paths to prevent path traversal attacks.
+     * @param filepath Path to validate
+     * @returns True if path is valid and safe
+     */
+    private isValidPath;
+    /**
+     * Escapes shell arguments to prevent command injection.
+     * @param arg Argument to escape
+     * @returns Escaped argument safe for shell execution
+     */
+    private escapeShellArg;
+    /**
+     * Sanitizes strings for safe logging to prevent log injection.
+     * @param input String to sanitize
+     * @returns Sanitized string safe for logging
+     */
+    private sanitizeForLog;
+}
+//# sourceMappingURL=BackupService.d.ts.map

package/dist/advanced/backup/BackupService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackupService.d.ts","sourceRoot":"","sources":["../../../src/advanced/backup/BackupService.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAOhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAsC;IAErD;;;OAGG;gBACS,MAAM,EAAE,YAAY;IAchC;;;OAGG;IAIG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IA6HzD;;;;OAIG;IAEG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IA4GpE;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,EAAE,CAAC,CAAC;IAiB1D;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAI3D;;;OAGG;IACG,qBAAqB,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAuC5D;;;OAGG;YACW,YAAY;IAmB1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAInB;;;OAGG;YACW,YAAY;IAW1B;;;OAGG;YACW,cAAc;IAW5B;;;OAGG;YACW,WAAW;IAkBzB;;;OAGG;YACW,WAAW;IAuCzB;;;OAGG;YACW,UAAU;IAqCxB;;;;OAIG;YACW,cAAc;IAqC5B;;;OAGG;YACW,YAAY;IA2B1B;;OAEG;IACH,OAAO,CAAC,eAAe;IA8BvB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAwBnB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAatB;;;;OAIG;IACH,OAAO,CAAC,cAAc;CAQvB"}

package/dist/advanced/backup/index.d.ts

@@ -0,0 +1,2 @@
+export { BackupService } from "./BackupService";
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/backup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/backup/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/advanced/caching/CacheEvict.decorator.d.ts

@@ -0,0 +1,3 @@
+import type { CacheEvictOptions } from "@plyaz/types";
+export declare function CacheEvict(options?: CacheEvictOptions): MethodDecorator;
+//# sourceMappingURL=CacheEvict.decorator.d.ts.map

package/dist/advanced/caching/CacheEvict.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheEvict.decorator.d.ts","sourceRoot":"","sources":["../../../src/advanced/caching/CacheEvict.decorator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAmPtD,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,eAAe,CAsC3E"}

package/dist/advanced/caching/Cacheable.decorator.d.ts

@@ -0,0 +1,99 @@
+import type { CacheableOptions } from "@plyaz/types/db";
+/**
+ * Decorator that caches the result of a method.
+ * Automatically generates cache keys and handles TTL.
+ *
+ * @example
+ * ### Basic Usage
+ * ```typescript
+ * class UserService {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   @Cacheable({ ttl: 300 }) // Cache for 5 minutes
+ *   async getUserById(id: string): Promise<DatabaseResult<User>> {
+ *     // First call: executes query and caches result
+ *     // Subsequent calls: returns cached result for 5 minutes
+ *     return this.db.findById('users', id);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Custom Cache Key
+ * ```typescript
+ * class ProductService {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   @Cacheable({
+ *     key: 'featured-products',
+ *     ttl: 1800 // Cache for 30 minutes
+ *   })
+ *   async getFeaturedProducts(): Promise<DatabaseResult<Product[]>> {
+ *     // Uses custom cache key 'featured-products'
+ *     return this.db.findMany('products', {
+ *       filter: { field: 'featured', operator: 'eq', value: true }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Conditional Caching
+ * ```typescript
+ * class OrderService {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   @Cacheable({
+ *     ttl: 600,
+ *     condition: (result) => result.success && result.value?.length > 0
+ *   })
+ *   async getRecentOrders(): Promise<DatabaseResult<Order[]>> {
+ *     // Only caches successful responses with non-empty results
+ *     // Prevents caching empty arrays or error responses
+ *     return this.db.findMany('orders', {
+ *       sort: [{ field: 'createdAt', direction: 'desc' }],
+ *       pagination: { limit: 10 }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### User Profile Caching
+ * ```typescript
+ * class ProfileService {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   @Cacheable({ ttl: 3600 }) // Cache for 1 hour
+ *   async getUserProfile(userId: string): Promise<DatabaseResult<Profile>> {
+ *     // User profiles change infrequently, perfect for caching
+ *     return this.db.findById('profiles', userId);
+ *   }
+ *
+ *   @CacheEvict({ key: 'user-profile' })
+ *   async updateProfile(userId: string, data: Partial<Profile>): Promise<DatabaseResult<Profile>> {
+ *     // When profile is updated, evict the cached version
+ *     return this.db.update('profiles', userId, data);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Analytics Data Caching
+ * ```typescript
+ * class AnalyticsService {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   @Cacheable({
+ *     ttl: 7200, // Cache for 2 hours
+ *     key: 'daily-stats'
+ *   })
+ *   async getDailyStats(date: string): Promise<DatabaseResult<DailyStats>> {
+ *     // Analytics queries are expensive, cache them longer
+ *     return this.db.findById('daily_stats', date);
+ *   }
+ * }
+ * ```
+ */
+export declare function Cacheable(options?: CacheableOptions): MethodDecorator;
+//# sourceMappingURL=Cacheable.decorator.d.ts.map

package/dist/advanced/caching/Cacheable.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cacheable.decorator.d.ts","sourceRoot":"","sources":["../../../src/advanced/caching/Cacheable.decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,iBAAiB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,eAAe,CAsDzE"}

package/dist/advanced/caching/RedisCache.d.ts

@@ -0,0 +1,417 @@
+import type { DatabaseResult } from "@plyaz/types/db";
+/**
+ * Redis-based caching service for database query results.
+ * Provides automatic serialization/deserialization, TTL management, and pattern-based invalidation.
+ *
+ * @example
+ * ### Basic Usage
+ * ```typescript
+ * const cache = new RedisCache({
+ *   url: 'redis://localhost:6379',
+ *   defaultTTL: 3600 // 1 hour
+ * });
+ *
+ * // Set a value
+ * await cache.set('user:123', { id: 123, name: 'John' });
+ *
+ * // Get a value
+ * const result = await cache.get('user:123');
+ * if (result.success) {
+ *   console.log(result.value); // { id: 123, name: 'John' }
+ * }
+ *
+ * // Delete a value
+ * await cache.del('user:123');
+ * ```
+ *
+ * @example
+ * ### User Profile Caching
+ * ```typescript
+ * class UserProfileCache {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   async getUserProfile(userId: string): Promise<DatabaseResult<UserProfile>> {
+ *     const cacheKey = `profile:${userId}`;
+ *
+ *     // Try cache first
+ *     const cached = await this.cache.get<UserProfile>(cacheKey);
+ *     if (cached.success && cached.value) {
+ *       return cached;
+ *     }
+ *
+ *     // Fetch from database
+ *     const profile = await this.db.findById('profiles', userId);
+ *
+ *     // Cache the result
+ *     if (profile.success) {
+ *       await this.cache.set(cacheKey, profile.value, 1800); // 30 minutes
+ *     }
+ *
+ *     return profile;
+ *   }
+ *
+ *   async updateUserProfile(userId: string, data: Partial<UserProfile>): Promise<DatabaseResult<UserProfile>> {
+ *     const updated = await this.db.update('profiles', userId, data);
+ *
+ *     // Invalidate cache on successful update
+ *     if (updated.success) {
+ *       await this.cache.del(`profile:${userId}`);
+ *       // Also invalidate related caches
+ *       await this.cache.invalidatePattern(`user:${userId}:*`);
+ *     }
+ *
+ *     return updated;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Product Catalog Caching
+ * ```typescript
+ * class ProductCatalogCache {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   async getProductsByCategory(categoryId: string): Promise<DatabaseResult<Product[]>> {
+ *     const cacheKey = `products:category:${categoryId}`;
+ *
+ *     const cached = await this.cache.get<Product[]>(cacheKey);
+ *     if (cached.success && cached.value) {
+ *       return cached;
+ *     }
+ *
+ *     const products = await this.db.findMany('products', {
+ *       filter: { field: 'categoryId', operator: 'eq', value: categoryId }
+ *     });
+ *
+ *     // Cache product lists longer (2 hours) as they change less frequently
+ *     if (products.success) {
+ *       await this.cache.set(cacheKey, products.value, 7200);
+ *     }
+ *
+ *     return products;
+ *   }
+ *
+ *   async updateProductStock(productId: string, quantity: number): Promise<DatabaseResult<void>> {
+ *     await this.db.update('inventory', productId, { quantity });
+ *
+ *     // Invalidate product cache and related caches
+ *     await this.cache.del(`product:${productId}`);
+ *     await this.cache.invalidatePattern(`products:category:*`);
+ *     await this.cache.invalidatePattern(`inventory:low-stock`);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Multi-tenant Caching
+ * ```typescript
+ * class MultiTenantCache {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   async getTenantConfig(tenantId: string): Promise<DatabaseResult<TenantConfig>> {
+ *     const cacheKey = `tenant:${tenantId}:config`;
+ *
+ *     const cached = await this.cache.get<TenantConfig>(cacheKey);
+ *     if (cached.success && cached.value) {
+ *       return cached;
+ *     }
+ *
+ *     const config = await this.db.findById('tenant_configs', tenantId);
+ *
+ *     // Cache configs longer (4 hours) as they rarely change
+ *     if (config.success) {
+ *       await this.cache.set(cacheKey, config.value, 14400);
+ *     }
+ *
+ *     return config;
+ *   }
+ *
+ *   async updateTenantSettings(tenantId: string): Promise<DatabaseResult<void>> {
+ *     await this.db.update('tenant_settings', tenantId, { updatedAt: new Date() });
+ *
+ *     // Invalidate all tenant-related caches
+ *     await this.cache.invalidatePattern(`tenant:${tenantId}:*`);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Analytics Data Caching
+ * ```typescript
+ * class AnalyticsCache {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   async getDailyStats(date: string): Promise<DatabaseResult<DailyStats>> {
+ *     const cacheKey = `analytics:daily:${date}`;
+ *
+ *     const cached = await this.cache.get<DailyStats>(cacheKey);
+ *     if (cached.success && cached.value) {
+ *       return cached;
+ *     }
+ *
+ *     // Analytics queries are expensive, cache them longer
+ *     const stats = await this.db.findById('daily_stats', date);
+ *
+ *     if (stats.success) {
+ *       // Cache for 6 hours as analytics data doesn't change frequently
+ *       await this.cache.set(cacheKey, stats.value, 21600);
+ *     }
+ *
+ *     return stats;
+ *   }
+ *
+ *   async recordMetric(metric: MetricData): Promise<DatabaseResult<void>> {
+ *     await this.db.create('metrics', metric);
+ *
+ *     // Invalidate aggregated analytics caches
+ *     await this.cache.invalidatePattern('analytics:aggregated:*');
+ *     await this.cache.invalidatePattern('analytics:dashboard:*');
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Session Management
+ * ```typescript
+ * class SessionCache {
+ *   constructor(private cache: RedisCache) {}
+ *
+ *   async getUserSession(sessionId: string): Promise<DatabaseResult<Session>> {
+ *     const cacheKey = `session:${sessionId}`;
+ *
+ *     // Sessions are accessed frequently, cache them but with short TTL
+ *     const cached = await this.cache.get<Session>(cacheKey);
+ *     if (cached.success && cached.value) {
+ *       return cached;
+ *     }
+ *
+ *     const session = await this.db.findById('sessions', sessionId);
+ *
+ *     if (session.success) {
+ *       // Cache sessions for 15 minutes
+ *       await this.cache.set(cacheKey, session.value, 900);
+ *     }
+ *
+ *     return session;
+ *   }
+ *
+ *   async invalidateUserSessions(userId: string): Promise<DatabaseResult<void>> {
+ *     // Invalidate all sessions for a user (e.g., on logout or password change)
+ *     await this.cache.invalidatePattern(`session:user:${userId}:*`);
+ *   }
+ * }
+ * ```
+ */
+export declare class RedisCache {
+    private redis;
+    private defaultTTL;
+    /**
+     * Creates a new RedisCache instance.
+     * @param config Redis configuration
+     *
+     * @example
+     * ```typescript
+     * // Basic configuration
+     * const cache = new RedisCache({
+     *   url: 'redis://localhost:6379'
+     * });
+     *
+     * // With custom default TTL
+     * const cacheWithCustomTTL = new RedisCache({
+     *   url: 'redis://localhost:6379',
+     *   defaultTTL: 1800 // 30 minutes
+     * });
+     *
+     * // Production configuration with options
+     * const productionCache = new RedisCache({
+     *   url: 'redis://redis-cluster.example.com:6379',
+     *   defaultTTL: 3600,
+     *   // Additional Redis options can be passed here
+     * });
+     * ```
+     */
+    constructor(config: {
+        url: string;
+        defaultTTL?: number;
+    });
+    /**
+     * Retrieves a value from cache by key.
+     * Automatically handles JSON deserialization.
+     *
+     * @param key Cache key
+     * @returns DatabaseResult containing cached value or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Get user profile
+     * const result = await cache.get<UserProfile>('profile:123');
+     * if (result.success && result.value) {
+     *   console.log('User:', result.value.name);
+     * } else {
+     *   console.log('Profile not found or cache error');
+     * }
+     *
+     * // Get product list
+     * const products = await cache.get<Product[]>('products:featured');
+     * if (products.success && products.value) {
+     *   products.value.forEach(product => {
+     *     console.log(product.name, product.price);
+     *   });
+     * }
+     * ```
+     */
+    get<T extends object>(key: string): Promise<DatabaseResult<T | null>>;
+    /**
+     * Sets a value in cache with optional TTL.
+     * Automatically handles JSON serialization.
+     *
+     * @param key Cache key
+     * @param value Value to cache
+     * @param ttl Time to live in seconds (uses default if not specified)
+     * @returns DatabaseResult indicating operation success
+     *
+     * @example
+     * ```typescript
+     * // Cache with default TTL
+     * await cache.set('user:123', { id: 123, name: 'John' });
+     *
+     * // Cache with custom TTL (5 minutes)
+     * await cache.set('session:abc123', sessionData, 300);
+     *
+     * // Cache with long TTL for static data
+     * await cache.set('config:app-settings', appSettings, 86400); // 24 hours
+     *
+     * // Cache with short TTL for frequently changing data
+     * await cache.set('metrics:realtime', realtimeData, 60); // 1 minute
+     * ```
+     */
+    set<T extends object>(key: string, value: T, ttl?: number): Promise<DatabaseResult<null>>;
+    /**
+     * Deletes a value from cache.
+     *
+     * @param key Cache key
+     * @returns DatabaseResult indicating operation success
+     *
+     * @example
+     * ```typescript
+     * // Delete specific cache entry
+     * await cache.del('user:123');
+     *
+     * // Delete session on logout
+     * await cache.del(`session:${sessionId}`);
+     *
+     * // Delete cached configuration
+     * await cache.del('config:feature-flags');
+     * ```
+     */
+    del(key: string): Promise<DatabaseResult<null>>;
+    /**
+     * Invalidates all cache entries matching a pattern.
+     * Useful for clearing related cache entries when data changes.
+     *
+     * @param pattern Redis key pattern (e.g., 'users:*')
+     * @returns DatabaseResult indicating operation success
+     *
+     * @example
+     * ```typescript
+     * // Invalidate all user-related caches
+     * await cache.invalidatePattern('users:*');
+     *
+     * // Invalidate all caches for a specific category
+     * await cache.invalidatePattern('products:category:electronics:*');
+     *
+     * // Invalidate all session caches
+     * await cache.invalidatePattern('session:*');
+     *
+     * // Invalidate all caches for a tenant
+     * await cache.invalidatePattern(`tenant:${tenantId}:*`);
+     *
+     * // Invalidate all analytics caches
+     * await cache.invalidatePattern('analytics:*');
+     * ```
+     */
+    invalidatePattern(pattern: string): Promise<DatabaseResult<null>>;
+    /**
+     * Generates a cache key for database queries.
+     * Creates consistent, URL-safe keys that include table, operation, and parameters.
+     *
+     * @param table Database table name
+     * @param operation Database operation type
+     * @param params Query parameters object
+     * @returns Generated cache key
+     *
+     * @example
+     * ```typescript
+     * // Simple key generation
+     * const key = cache.generateKey('users', 'findById', { id: '123' });
+     * // Returns: 'db:users:findById:eyJpYXJhbTAiOiIxMjMifQ=='
+     *
+     * // Complex query key
+     * const complexKey = cache.generateKey('products', 'findMany', {
+     *   filter: { field: 'category', operator: 'eq', value: 'electronics' },
+     *   sort: [{ field: 'price', direction: 'asc' }],
+     *   pagination: { limit: 20, offset: 0 }
+     * });
+     *
+     * // User-specific key
+     * const userKey = cache.generateKey('orders', 'findMany', {
+     *   filter: { field: 'userId', operator: 'eq', value: '123' }
+     * });
+     * ```
+     */
+    generateKey(table: string, operation: string, params: Record<string, string | number | boolean | null>): string;
+    /**
+     * Performs a health check on the Redis connection.
+     * Useful for monitoring and ensuring cache availability.
+     *
+     * @returns DatabaseResult with boolean indicating if Redis is healthy
+     *
+     * @example
+     * ```typescript
+     * // Check Redis health
+     * const health = await cache.healthCheck();
+     * if (health.success && health.value) {
+     *   console.log('Redis is healthy');
+     * } else {
+     *   console.log('Redis health check failed:', health.error?.message);
+     *   // Implement fallback logic or alerting
+     * }
+     *
+     * // Use in health check endpoint
+     * app.get('/health', async (req, res) => {
+     *   const dbHealth = await db.healthCheck();
+     *   const cacheHealth = await cache.healthCheck();
+     *
+     *   res.json({
+     *     database: dbHealth.success && dbHealth.value,
+     *     cache: cacheHealth.success && cacheHealth.value,
+     *     timestamp: new Date()
+     *   });
+     * });
+     * ```
+     */
+    healthCheck(): Promise<DatabaseResult<boolean>>;
+    /**
+     * Closes the Redis connection gracefully.
+     * Should be called during application shutdown.
+     *
+     * @example
+     * ```typescript
+     * // In your application shutdown logic
+     * async function shutdown() {
+     *   console.log('Shutting down cache...');
+     *   await cache.close();
+     *   console.log('Cache connection closed');
+     *
+     *   // Close other connections...
+     *   process.exit(0);
+     * }
+     *
+     * // Handle graceful shutdown
+     * process.on('SIGTERM', shutdown);
+     * process.on('SIGINT', shutdown);
+     * ```
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=RedisCache.d.ts.map