@zintrust/core 0.1.28 → 0.1.30

package/src/builder/BundleOptimizer.ts

@@ -1,483 +0,0 @@
-/**
- * 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';
-import fs from '@node-singletons/fs';
-import * as path from '@node-singletons/path';
-
-export interface OptimizationOptions {
-  platform: 'lambda' | 'cloudflare' | 'deno' | 'fargate';
-  targetSize?: number; // Max bundle size in MB
-  analyzeOnly?: boolean;
-  verbose?: boolean;
-}
-
-export interface BundleAnalysis {
-  platform: string;
-  totalSize: number;
-  files: Array<{
-    path: string;
-    size: number;
-    percentage: number;
-  }>;
-  recommendations: string[];
-}
-
-export interface IBundleOptimizer {
-  optimize(): Promise<BundleAnalysis>;
-}
-
-/**
- * Bundle optimizer - reduces deployed package size
- * Sealed namespace for immutability
- */
-export const BundleOptimizer = Object.freeze({
-  /**
-   * Create a new bundle optimizer instance
-   */
-  create(options: OptimizationOptions): IBundleOptimizer {
-    const distDir = path.resolve('dist');
-
-    return {
-      /**
-       * Run optimization for target platform
-       */
-      async optimize(): Promise<BundleAnalysis> {
-        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: string): Promise<string[]> {
-  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: BundleAnalysis['files'],
-  totalSize: number,
-  options: OptimizationOptions
-): string[] {
-  const recommendations: string[] = [];
-  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: BundleAnalysis): void {
-  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: string, options: OptimizationOptions): Promise<BundleAnalysis> {
-  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: string,
-  options: OptimizationOptions,
-  ...adapters: string[]
-): Promise<void> {
-  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: string, options: OptimizationOptions): Promise<void> {
-  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: boolean = false): Promise<void> {
-  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: string,
-  options: OptimizationOptions,
-  modulePath: string
-): Promise<void> {
-  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: string): boolean {
-  // Placeholder - would check imports in compiled code
-  return true;
-}
-
-/**
- * Remove unused middleware
- */
-async function removeUnusedMiddleware(
-  distDir: string,
-  options: OptimizationOptions
-): Promise<void> {
-  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: number): void {
-  Logger.info(`  → Inlining files smaller than ${(threshold / 1024).toFixed(0)} KB...`);
-  // Placeholder for actual inlining logic
-}
-
-/**
- * Remove files matching patterns
- */
-async function removeFiles(
-  distDir: string,
-  options: OptimizationOptions,
-  patterns: string[]
-): Promise<void> {
-  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: string, options: OptimizationOptions): Promise<void> {
-  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: string, options: OptimizationOptions): Promise<void> {
-  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: string, options: OptimizationOptions): Promise<void> {
-  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: string, options: OptimizationOptions): Promise<void> {
-  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(): Promise<void> {
-  const platform = (process.argv[2] as OptimizationOptions['platform']) || '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.ts

@@ -1,185 +0,0 @@
-/**
- * Cache Manager
- * Central cache management and driver resolution
- * Sealed namespace pattern - all exports through Cache namespace
- */
-
-import type { CacheDriver } from '@cache/CacheDriver';
-import { CacheDriverRegistry } from '@cache/CacheDriverRegistry';
-import { KVDriver } from '@cache/drivers/KVDriver';
-import { KVRemoteDriver } from '@cache/drivers/KVRemoteDriver';
-import { MemoryDriver } from '@cache/drivers/MemoryDriver';
-import { MongoDriver } from '@cache/drivers/MongoDriver';
-import { RedisDriver } from '@cache/drivers/RedisDriver';
-import { cacheConfig } from '@config/cache';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-
-const instances: Map<string, CacheDriver> = new Map();
-
-type DriverWithCreate = {
-  create: () => CacheDriver;
-};
-
-type DriverConstructor = new () => CacheDriver;
-
-function buildDriver(driver: unknown): CacheDriver {
-  const maybeCreate = (driver as Partial<DriverWithCreate>).create;
-  if (typeof maybeCreate === 'function') {
-    return maybeCreate();
-  }
-
-  if (typeof driver === 'function') {
-    return new (driver as unknown as DriverConstructor)();
-  }
-
-  throw ErrorFactory.createGeneralError('Invalid cache driver export');
-}
-
-function resolveDriver(storeName?: string): CacheDriver {
-  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?: string): CacheDriver {
-  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 <T>(key: string): Promise<T | null> => {
-  const value = await getDriverInstance().get<T>(key);
-  return value;
-};
-
-/**
- * Store an item in the cache
- */
-const set = async <T>(key: string, value: T, ttl?: number): Promise<void> => {
-  await getDriverInstance().set(key, value, ttl);
-};
-
-/**
- * Remove an item from the cache
- */
-const del = async (key: string): Promise<void> => {
-  await getDriverInstance().delete(key);
-};
-
-/**
- * Clear all items from the cache
- */
-const clear = async (): Promise<void> => {
-  await getDriverInstance().clear();
-};
-
-/**
- * Check if an item exists in the cache
- */
-const has = async (key: string): Promise<boolean> => {
-  const exists = await getDriverInstance().has(key);
-  return exists;
-};
-
-/**
- * Get the underlying driver instance
- */
-const getDriver = (): CacheDriver => {
-  return getDriverInstance();
-};
-
-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;
-}>;
-
-const store = (name?: string): CacheStore => {
-  const getFromStore = async <T>(key: string): Promise<T | null> => {
-    return getDriverInstance(name).get<T>(key);
-  };
-
-  const setInStore = async <T>(key: string, value: T, ttl?: number): Promise<void> => {
-    await getDriverInstance(name).set(key, value, ttl);
-  };
-
-  const delFromStore = async (key: string): Promise<void> => {
-    await getDriverInstance(name).delete(key);
-  };
-
-  const clearStore = async (): Promise<void> => {
-    await getDriverInstance(name).clear();
-  };
-
-  const hasInStore = async (key: string): Promise<boolean> => {
-    return getDriverInstance(name).has(key);
-  };
-
-  const getStoreDriver = (): CacheDriver => {
-    return getDriverInstance(name);
-  };
-
-  return Object.freeze({
-    get: getFromStore,
-    set: setInStore,
-    delete: delFromStore,
-    clear: clearStore,
-    has: hasInStore,
-    getDriver: getStoreDriver,
-  });
-};
-
-const reset = (): void => {
-  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.ts

@@ -1,39 +0,0 @@
-/**
- * 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>;
-}
-
-// Runtime marker to make this type-only module coverable in V8 coverage.
-export const CACHE_DRIVER_INTERFACE = 'CacheDriver';