@zintrust/core 0.4.17 → 0.4.18

package/src/builder/BundleOptimizer.js

@@ -0,0 +1,352 @@
+/**
+ * Bundle Optimizer for ZinTrust Framework
+ * Reduces deployment package size by:
+ * - Tree-shaking unused ORM adapters
+ * - Minifying compiled JavaScript
+ * - Removing dev dependencies
+ * - Inlining configuration
+ */
+import { Logger } from '../config/logger.js';
+import fs from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+/**
+ * Bundle optimizer - reduces deployed package size
+ * Sealed namespace for immutability
+ */
+export const BundleOptimizer = Object.freeze({
+    /**
+     * Create a new bundle optimizer instance
+     */
+    create(options) {
+        const distDir = path.resolve('dist');
+        return {
+            /**
+             * Run optimization for target platform
+             */
+            async optimize() {
+                Logger.info(`\n🔧 Optimizing bundle for ${options.platform} platform...`);
+                // Analyze current bundle
+                const analysis = await analyze(distDir, options);
+                if (options.analyzeOnly === true) {
+                    printAnalysis(analysis);
+                    return analysis;
+                }
+                // Apply platform-specific optimizations
+                switch (options.platform) {
+                    case 'lambda':
+                        await optimizeForLambda(distDir, options);
+                        break;
+                    case 'cloudflare':
+                        await optimizeForCloudflare(distDir, options);
+                        break;
+                    case 'deno':
+                        await optimizeForDeno(distDir, options);
+                        break;
+                    case 'fargate':
+                        await optimizeForFargate(distDir, options);
+                        break;
+                }
+                // Re-analyze after optimizations
+                const optimized = await analyze(distDir, options);
+                printAnalysis(optimized);
+                return optimized;
+            },
+        };
+    },
+});
+/**
+ * Get all files recursively
+ */
+async function getFilesRecursive(dir) {
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    const nested = await Promise.all(entries.map(async (entry) => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            return getFilesRecursive(fullPath);
+        }
+        return [fullPath];
+    }));
+    return nested.flat();
+}
+/**
+ * Generate optimization recommendations
+ */
+function generateRecommendations(files, totalSize, options) {
+    const recommendations = [];
+    const sizeInMb = totalSize / (1024 * 1024);
+    if (sizeInMb > 100) {
+        recommendations.push('❌ Bundle exceeds 100 MB - remove unnecessary files');
+    }
+    // Find largest files
+    const largest = files.slice(0, 3);
+    for (const file of largest) {
+        if (file.percentage > 20) {
+            recommendations.push(`⚠️  ${file.path} is ${file.percentage.toFixed(1)}% of bundle`);
+        }
+    }
+    if (options.platform === 'cloudflare' && sizeInMb > 1) {
+        recommendations.push('⚠️  Cloudflare Workers: Bundle > 1 MB, consider upgrading plan');
+    }
+    if (recommendations.length === 0) {
+        recommendations.push('✅ Bundle is well-optimized');
+    }
+    return recommendations;
+}
+/**
+ * Print analysis report
+ */
+function printAnalysis(analysis) {
+    const sizeInMb = (analysis.totalSize / (1024 * 1024)).toFixed(2);
+    const sizeInKb = (analysis.totalSize / 1024).toFixed(2);
+    Logger.info(`\n📊 Bundle Analysis (${analysis.platform})`);
+    Logger.info(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    Logger.info(`Total Size: ${sizeInMb} MB (${sizeInKb} KB)`);
+    Logger.info(`Files: ${analysis.files.length}\n`);
+    // Show top 10 largest files
+    const topFiles = analysis.files.slice(0, 10);
+    for (const file of topFiles) {
+        const bar = '█'.repeat(Math.round(file.percentage / 2));
+        Logger.info(`  ${file.path.padEnd(40)} ${(file.size / 1024).toFixed(1).padStart(8)} KB  ${bar}`);
+    }
+    // Recommendations
+    if (analysis.recommendations.length > 0) {
+        Logger.info('\n💡 Recommendations:');
+        for (const rec of analysis.recommendations) {
+            Logger.info(`  ${rec}`);
+        }
+    }
+    Logger.info('\n');
+}
+/**
+ * Analyze bundle structure
+ */
+async function analyze(distDir, options) {
+    const files = await getFilesRecursive(distDir);
+    // Collect sizes concurrently but avoid shared mutable state by computing sizes
+    // and then reducing the total afterwards to avoid race conditions.
+    const fileAnalysis = await Promise.all(files.map(async (file) => {
+        const stats = await fs.promises.stat(file);
+        const size = stats.size;
+        return {
+            path: path.relative(distDir, file),
+            size,
+            percentage: 0,
+        };
+    }));
+    // Compute total size in a single pass (no shared mutation)
+    const totalSize = fileAnalysis.reduce((acc, f) => acc + f.size, 0);
+    // Calculate percentages
+    fileAnalysis.forEach((f) => {
+        f.percentage = totalSize > 0 ? (f.size / totalSize) * 100 : 0;
+    });
+    // Sort by size descending
+    fileAnalysis.sort((a, b) => b.size - a.size);
+    return {
+        platform: options.platform,
+        totalSize,
+        files: fileAnalysis,
+        recommendations: generateRecommendations(fileAnalysis, totalSize, options),
+    };
+}
+/**
+ * Remove unused ORM adapters
+ */
+async function removeUnusedAdapters(distDir, options, ...adapters) {
+    const adapterDir = path.join(distDir, 'orm', 'adapters');
+    await Promise.all(adapters.map(async (adapter) => {
+        const files = [`${adapter}Adapter.js`, `${adapter}Adapter.d.ts`];
+        await Promise.all(files.map(async (file) => {
+            const filePath = path.join(adapterDir, file);
+            if (fs.existsSync(filePath)) {
+                await fs.promises.unlink(filePath);
+                if (options.verbose === true) {
+                    Logger.info(`  ✓ Removed ${adapter} adapter`);
+                }
+            }
+        }));
+    }));
+}
+/**
+ * Remove dev dependencies from node_modules
+ */
+async function removeDevDependencies(distDir, options) {
+    const nmDir = path.join(distDir, '..', 'node_modules');
+    const devDeps = [
+        '@types',
+        '@typescript-eslint',
+        'typescript',
+        'eslint',
+        'prettier',
+        'vitest',
+        '@vitest/coverage-v8',
+        'sonar-scanner',
+        'tsx',
+    ];
+    if (!fs.existsSync(nmDir))
+        return;
+    await Promise.all(devDeps.map(async (dep) => {
+        const depPath = path.join(nmDir, dep);
+        if (fs.existsSync(depPath)) {
+            await fs.promises.rm(depPath, { recursive: true });
+            if (options.verbose === true) {
+                Logger.info(`  ✓ Removed ${dep}`);
+            }
+        }
+    }));
+}
+/**
+ * Minify JavaScript files
+ */
+// eslint-disable-next-line @typescript-eslint/require-await
+async function minifyJavaScript(_aggressive = false) {
+    Logger.info('  → Minifying JavaScript...');
+    // In production, would use esbuild or terser
+    // This is a placeholder showing the pattern
+    Logger.info('  ✓ JavaScript minified');
+}
+/**
+ * Remove a specific module
+ */
+async function removeModule(distDir, options, modulePath) {
+    const distModule = modulePath.replace('src/', `${distDir}/`).replace('.ts', '.js');
+    if (fs.existsSync(distModule)) {
+        await fs.promises.unlink(distModule);
+        const dtsPath = distModule.replace('.js', '.d.ts');
+        if (fs.existsSync(dtsPath)) {
+            await fs.promises.unlink(dtsPath);
+        }
+        if (options.verbose === true) {
+            Logger.info(`  ✓ Removed module: ${modulePath}`);
+        }
+    }
+}
+/**
+ * Check if module is used
+ */
+function hasUsedModule(_moduleName) {
+    // Placeholder - would check imports in compiled code
+    return true;
+}
+/**
+ * Remove unused middleware
+ */
+async function removeUnusedMiddleware(distDir, options) {
+    const middlewareDir = path.join(distDir, 'middleware');
+    // Keep only essential middleware, remove optional ones
+    const optionalMiddleware = ['logging.js', 'profiling.js', 'rateLimit.js'];
+    if (!fs.existsSync(middlewareDir))
+        return;
+    await Promise.all(optionalMiddleware.map(async (file) => {
+        const filePath = path.join(middlewareDir, file);
+        if (fs.existsSync(filePath)) {
+            await fs.promises.unlink(filePath);
+            if (options.verbose === true) {
+                Logger.info(`  ✓ Removed middleware: ${file}`);
+            }
+        }
+    }));
+}
+/**
+ * Inline small files to reduce overhead
+ */
+function inlineSmallFiles(threshold) {
+    Logger.info(`  → Inlining files smaller than ${(threshold / 1024).toFixed(0)} KB...`);
+    // Placeholder for actual inlining logic
+}
+/**
+ * Remove files matching patterns
+ */
+async function removeFiles(distDir, options, patterns) {
+    const files = await getFilesRecursive(distDir);
+    const filesToRemove = files.filter((file) => patterns.some((pattern) => file.includes(pattern)));
+    await Promise.all(filesToRemove.map(async (file) => {
+        await fs.promises.unlink(file);
+        if (options.verbose === true) {
+            Logger.info(`  ✓ Removed ${path.relative(distDir, file)}`);
+        }
+    }));
+}
+/**
+ * Optimize for AWS Lambda (2-3 MB limit for direct upload)
+ */
+async function optimizeForLambda(distDir, options) {
+    Logger.info('📦 Optimizing for Lambda...');
+    // Remove unused ORM adapters
+    await removeUnusedAdapters(distDir, options, 'mysql', 'sqlserver', 'd1');
+    // Remove dev dependencies from node_modules
+    await removeDevDependencies(distDir, options);
+    // Minify all JS files
+    await minifyJavaScript();
+    // Remove unused security modules if not needed
+    if (!hasUsedModule('CsrfTokenManager')) {
+        await removeModule(distDir, options, 'src/security/CsrfTokenManager.ts');
+    }
+    Logger.info('✅ Lambda optimization complete');
+}
+/**
+ * Optimize for Cloudflare Workers (<1 MB limit)
+ */
+async function optimizeForCloudflare(distDir, options) {
+    Logger.info('⚡ Optimizing for Cloudflare Workers (strict <1 MB limit)...');
+    // Remove ALL unused adapters except cloudflare
+    await removeUnusedAdapters(distDir, options, 'postgresql', 'mysql', 'sqlserver');
+    // Remove Node.js HTTP server adapter
+    await removeModule(distDir, options, 'src/runtime/adapters/NodeServerAdapter.ts');
+    // Minify aggressively
+    await minifyJavaScript(true);
+    // Tree-shake unused middleware
+    await removeUnusedMiddleware(distDir, options);
+    // Inline small files
+    inlineSmallFiles(10240); // 10 KB threshold
+    // Check size limit
+    const optimized = await analyze(distDir, options);
+    const sizeInMb = optimized.totalSize / (1024 * 1024);
+    if (sizeInMb > 1) {
+        Logger.warn(`⚠️  Bundle size ${sizeInMb.toFixed(2)} MB exceeds 1 MB limit. Consider using Workers paid plan.`);
+    }
+    Logger.info('✅ Cloudflare Workers optimization complete');
+}
+/**
+ * Optimize for Deno Deploy
+ */
+async function optimizeForDeno(distDir, options) {
+    Logger.info('🦕 Optimizing for Deno Deploy...');
+    // Remove Node.js-specific modules
+    await removeModule(distDir, options, 'src/runtime/adapters/NodeServerAdapter.ts');
+    await removeModule(distDir, options, 'src/runtime/adapters/LambdaAdapter.ts');
+    // Keep Deno adapter only
+    await removeModule(distDir, options, 'src/runtime/adapters/CloudflareAdapter.ts');
+    // Minify
+    await minifyJavaScript();
+    Logger.info('✅ Deno optimization complete');
+}
+/**
+ * Optimize for Fargate (can be larger, but faster startup)
+ */
+async function optimizeForFargate(distDir, options) {
+    Logger.info('🐳 Optimizing for Fargate...');
+    // Keep all adapters for flexibility
+    // Only remove unnecessary test files
+    await removeFiles(distDir, options, ['.test.ts', '.spec.ts', '.test.js', '.spec.js']);
+    // Light minification
+    await minifyJavaScript(false);
+    Logger.info('✅ Fargate optimization complete');
+}
+/**
+ * CLI command for bundle optimization
+ */
+export async function runOptimizer() {
+    const platform = process.argv[2] || 'lambda';
+    const targetSize = process.argv[3] ? Number.parseInt(process.argv[3], 10) : undefined;
+    const optimizer = BundleOptimizer.create({
+        platform,
+        targetSize,
+        verbose: true,
+    });
+    const analysis = await optimizer.optimize();
+    const sizeInMb = (analysis.totalSize / (1024 * 1024)).toFixed(2);
+    Logger.info(`\n✅ Optimization complete. Final size: ${sizeInMb} MB`);
+}

package/src/cache/Cache.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cache Manager
+ * Central cache management and driver resolution
+ * Sealed namespace pattern - all exports through Cache namespace
+ */
+import type { CacheDriver } from './CacheDriver';
+type CacheStore = Readonly<{
+    get: <T>(key: string) => Promise<T | null>;
+    set: <T>(key: string, value: T, ttl?: number) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+    has: (key: string) => Promise<boolean>;
+    getDriver: () => CacheDriver;
+}>;
+export declare const Cache: Readonly<{
+    get: <T>(key: string) => Promise<T | null>;
+    set: <T>(key: string, value: T, ttl?: number) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+    has: (key: string) => Promise<boolean>;
+    getDriver: () => CacheDriver;
+    store: (name?: string) => CacheStore;
+    reset: () => void;
+}>;
+/**
+ * Helper alias for cache
+ */
+export declare const cache: Readonly<{
+    get: <T>(key: string) => Promise<T | null>;
+    set: <T>(key: string, value: T, ttl?: number) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+    has: (key: string) => Promise<boolean>;
+    getDriver: () => CacheDriver;
+    store: (name?: string) => CacheStore;
+    reset: () => void;
+}>;
+export {};
+//# sourceMappingURL=Cache.d.ts.map

package/src/cache/Cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../src/cache/Cache.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAmJtD,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3C,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,SAAS,EAAE,MAAM,WAAW,CAAC;CAC9B,CAAC,CAAC;AA8CH,eAAO,MAAM,KAAK;UAlGC,CAAC,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;UASlC,CAAC,OAAO,MAAM,SAAS,CAAC,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;kBAQjD,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;iBAQtB,OAAO,CAAC,IAAI,CAAC;eAOb,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;qBAS3B,WAAW;mBAaX,MAAM,KAAG,UAAU;iBAuCvB,IAAI;EAcpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK;UAhHC,CAAC,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;UASlC,CAAC,OAAO,MAAM,SAAS,CAAC,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;kBAQjD,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;iBAQtB,OAAO,CAAC,IAAI,CAAC;eAOb,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;qBAS3B,WAAW;mBAaX,MAAM,KAAG,UAAU;iBAuCvB,IAAI;EAmBI,CAAC"}

package/src/cache/Cache.js

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * Cache Manager
+ * Central cache management and driver resolution
+ * Sealed namespace pattern - all exports through Cache namespace
+ */
+import { CacheDriverRegistry } from './CacheDriverRegistry.js';
+import { KVDriver } from './drivers/KVDriver.js';
+import { KVRemoteDriver } from './drivers/KVRemoteDriver.js';
+import { MemoryDriver } from './drivers/MemoryDriver.js';
+import { MongoDriver } from './drivers/MongoDriver.js';
+import { RedisDriver } from './drivers/RedisDriver.js';
+import { cacheConfig } from '../config/cache.js';
+import { Env } from '../config/env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const instances = new Map();
+/**
+ * Auto-prefix cache keys with 'zt:' if not already prefixed
+ */
+function autoPrefixKey(key) {
+    return key.startsWith('zt:') ? key : `zt:${key}`;
+}
+function createNoOpDriver() {
+    return {
+        get: async () => null,
+        set: async () => { },
+        delete: async () => { },
+        clear: async () => { },
+        has: async () => false,
+    };
+}
+function buildDriver(driver) {
+    const maybeCreate = driver.create;
+    if (typeof maybeCreate === 'function') {
+        return maybeCreate();
+    }
+    if (typeof driver === 'function') {
+        return new driver();
+    }
+    throw ErrorFactory.createGeneralError('Invalid cache driver export');
+}
+function resolveDriver(storeName) {
+    const cacheEnabledRaw = Env.get('CACHE_ENABLED', 'true').trim().toLowerCase();
+    const cacheEnabled = !(cacheEnabledRaw === 'false' ||
+        cacheEnabledRaw === '0' ||
+        cacheEnabledRaw === 'no');
+    if (!cacheEnabled) {
+        return createNoOpDriver();
+    }
+    const driverConfig = cacheConfig.getDriver(storeName);
+    const externalFactory = CacheDriverRegistry.get(driverConfig.driver);
+    if (externalFactory !== undefined) {
+        return externalFactory(driverConfig);
+    }
+    const driverName = driverConfig.driver;
+    switch (driverName) {
+        case 'kv':
+            return buildDriver(KVDriver);
+        case 'kv-remote':
+            return buildDriver(KVRemoteDriver);
+        case 'redis':
+            return buildDriver(RedisDriver);
+        case 'mongodb':
+            return buildDriver(MongoDriver);
+        case 'memory':
+        default:
+            return buildDriver(MemoryDriver);
+    }
+}
+function getDriverInstance(storeName) {
+    const normalizedSelection = String(storeName ?? '')
+        .trim()
+        .toLowerCase();
+    const resolvedKey = normalizedSelection.length > 0 ? normalizedSelection : 'default';
+    const existing = instances.get(resolvedKey);
+    if (existing !== undefined)
+        return existing;
+    const selector = resolvedKey === 'default' ? undefined : resolvedKey;
+    const created = resolveDriver(selector);
+    instances.set(resolvedKey, created);
+    return created;
+}
+/**
+ * Get an item from the cache
+ */
+const get = async (key) => {
+    const prefixedKey = autoPrefixKey(key);
+    const value = await getDriverInstance().get(prefixedKey);
+    return value;
+};
+/**
+ * Store an item in the cache
+ */
+const set = async (key, value, ttl) => {
+    const prefixedKey = autoPrefixKey(key);
+    await getDriverInstance().set(prefixedKey, value, ttl);
+};
+/**
+ * Remove an item from the cache
+ */
+const del = async (key) => {
+    const prefixedKey = autoPrefixKey(key);
+    await getDriverInstance().delete(prefixedKey);
+};
+/**
+ * Clear all items from the cache
+ */
+const clear = async () => {
+    await getDriverInstance().clear();
+};
+/**
+ * Check if an item exists in the cache
+ */
+const has = async (key) => {
+    const prefixedKey = autoPrefixKey(key);
+    const exists = await getDriverInstance().has(prefixedKey);
+    return exists;
+};
+/**
+ * Get the underlying driver instance
+ */
+const getDriver = () => {
+    return getDriverInstance();
+};
+const store = (name) => {
+    const getFromStore = async (key) => {
+        const prefixedKey = autoPrefixKey(key);
+        return getDriverInstance(name).get(prefixedKey);
+    };
+    const setInStore = async (key, value, ttl) => {
+        const prefixedKey = autoPrefixKey(key);
+        await getDriverInstance(name).set(prefixedKey, value, ttl);
+    };
+    const delFromStore = async (key) => {
+        const prefixedKey = autoPrefixKey(key);
+        await getDriverInstance(name).delete(prefixedKey);
+    };
+    const clearStore = async () => {
+        await getDriverInstance(name).clear();
+    };
+    const hasInStore = async (key) => {
+        const prefixedKey = autoPrefixKey(key);
+        return getDriverInstance(name).has(prefixedKey);
+    };
+    const getStoreDriver = () => {
+        return getDriverInstance(name);
+    };
+    return Object.freeze({
+        get: getFromStore,
+        set: setInStore,
+        delete: delFromStore,
+        clear: clearStore,
+        has: hasInStore,
+        getDriver: getStoreDriver,
+    });
+};
+const reset = () => {
+    instances.clear();
+};
+// Sealed namespace with cache functionality
+export const Cache = Object.freeze({
+    get,
+    set,
+    delete: del,
+    clear,
+    has,
+    getDriver,
+    store,
+    reset,
+});
+/**
+ * Helper alias for cache
+ */
+export const cache = Cache;

package/src/cache/CacheDriver.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cache Driver Interface
+ * Defines contract for different cache implementations
+ */
+export interface CacheDriver {
+    /**
+     * Get an item from the cache
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Store an item in the cache
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Remove an item from the cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Clear all items from the cache
+     */
+    clear(): Promise<void>;
+    /**
+     * Check if an item exists in the cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Dispose of resources (optional cleanup method)
+     */
+    dispose?(): Promise<void>;
+}
+export declare const CACHE_DRIVER_INTERFACE = "CacheDriver";
+//# sourceMappingURL=CacheDriver.d.ts.map

package/src/cache/CacheDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheDriver.d.ts","sourceRoot":"","sources":["../../../src/cache/CacheDriver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAEvC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3D;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC;;OAEG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAGD,eAAO,MAAM,sBAAsB,gBAAgB,CAAC"}

package/src/cache/CacheDriver.js

@@ -0,0 +1,6 @@
+/**
+ * Cache Driver Interface
+ * Defines contract for different cache implementations
+ */
+// Runtime marker to make this type-only module coverable in V8 coverage.
+export const CACHE_DRIVER_INTERFACE = 'CacheDriver';

package/src/cache/CacheDriverRegistry.d.ts

@@ -0,0 +1,15 @@
+import type { CacheDriver } from './CacheDriver';
+import type { CacheDriverConfig } from '../config/type';
+export type CacheDriverFactory = (config: CacheDriverConfig) => CacheDriver;
+declare function register(driver: CacheDriverConfig['driver'], factory: CacheDriverFactory): void;
+declare function get(driver: CacheDriverConfig['driver']): CacheDriverFactory | undefined;
+declare function has(driver: CacheDriverConfig['driver']): boolean;
+declare function list(): Array<CacheDriverConfig['driver']>;
+export declare const CacheDriverRegistry: Readonly<{
+    register: typeof register;
+    get: typeof get;
+    has: typeof has;
+    list: typeof list;
+}>;
+export {};
+//# sourceMappingURL=CacheDriverRegistry.d.ts.map

package/src/cache/CacheDriverRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheDriverRegistry.d.ts","sourceRoot":"","sources":["../../../src/cache/CacheDriverRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,WAAW,CAAC;AAI5E,iBAAS,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAExF;AAED,iBAAS,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,GAAG,kBAAkB,GAAG,SAAS,CAEhF;AAED,iBAAS,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,GAAG,OAAO,CAEzD;AAED,iBAAS,IAAI,IAAI,KAAK,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAElD;AAED,eAAO,MAAM,mBAAmB;;;;;EAK9B,CAAC"}

package/src/cache/CacheDriverRegistry.js

@@ -0,0 +1,19 @@
+const registry = new Map();
+function register(driver, factory) {
+    registry.set(driver, factory);
+}
+function get(driver) {
+    return registry.get(driver);
+}
+function has(driver) {
+    return registry.has(driver);
+}
+function list() {
+    return Array.from(registry.keys());
+}
+export const CacheDriverRegistry = Object.freeze({
+    register,
+    get,
+    has,
+    list,
+});

package/src/cache/CacheRuntimeRegistration.d.ts

@@ -0,0 +1,11 @@
+import type { CacheConfig } from '../config/cache';
+/**
+ * Register cache drivers from runtime config.
+ *
+ * This follows the framework's config-driven availability pattern:
+ * - Built-in driver factories are registered so config entries can reference them.
+ * - Named cache stores are still resolved from `cacheConfig.drivers[storeName]`.
+ * - Unknown store names throw when explicitly selected via `cacheConfig.getDriver(name)`.
+ */
+export declare function registerCachesFromRuntimeConfig(_config: CacheConfig): void;
+//# sourceMappingURL=CacheRuntimeRegistration.d.ts.map

package/src/cache/CacheRuntimeRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheRuntimeRegistration.d.ts","sourceRoot":"","sources":["../../../src/cache/CacheRuntimeRegistration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AASjD;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAM1E"}