@zintrust/core 0.1.0

package/src/performance/Benchmark.js

@@ -0,0 +1,304 @@
+/**
+ * Benchmarking Suite - Performance Measurement Tools
+ * Measures code generation, memory usage, and overall performance
+ */
+import { fs } from '../node-singletons/index.js';
+/**
+ * Benchmark - Measure performance of operations
+ * Sealed namespace for immutability
+ */
+export const Benchmark = Object.freeze({
+    /**
+     * Create a new benchmark instance
+     */
+    create(name = 'Benchmark Suite') {
+        const results = [];
+        const suiteName = name;
+        const startTime = new Date();
+        return {
+            measure(name, fn, iterations = 1, metadata) {
+                const result = runMeasure(name, fn, iterations, metadata);
+                results.push(result);
+                return result;
+            },
+            async measureAsync(name, fn, iterations = 1, metadata) {
+                const result = await runMeasureAsync(name, fn, iterations, metadata);
+                results.push(result);
+                return result;
+            },
+            getResults: () => [...results],
+            getTable: () => getFormattedTable(results),
+            toJSON: () => getBenchmarkSuite(suiteName, startTime, results),
+            export(filePath) {
+                fs.writeFileSync(filePath, JSON.stringify(this.toJSON(), null, 2), 'utf-8');
+            },
+            compare: (previous) => compareBenchmarks(results, previous),
+            getComparisonReport: (comparison) => getFormattedComparisonReport(comparison),
+        };
+    },
+});
+/**
+ * Run synchronous measurement
+ */
+function runMeasure(name, fn, iterations, metadata) {
+    const durations = [];
+    const memBefore = process.memoryUsage().heapUsed;
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        fn();
+        const duration = performance.now() - start;
+        durations.push(duration);
+    }
+    const memAfter = process.memoryUsage().heapUsed;
+    const totalDuration = durations.reduce((a, b) => a + b, 0);
+    return {
+        name,
+        duration: totalDuration,
+        memoryBefore: memBefore,
+        memoryAfter: memAfter,
+        memoryDelta: memAfter - memBefore,
+        iterationCount: iterations,
+        averageTime: totalDuration / iterations,
+        averageMemory: (memAfter - memBefore) / iterations,
+        timestamp: new Date(),
+        metadata,
+    };
+}
+/**
+ * Run asynchronous measurement
+ */
+async function runMeasureAsync(name, fn, iterations, metadata) {
+    const durations = [];
+    const memBefore = process.memoryUsage().heapUsed;
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await fn();
+        const duration = performance.now() - start;
+        durations.push(duration);
+    }
+    const memAfter = process.memoryUsage().heapUsed;
+    const totalDuration = durations.reduce((a, b) => a + b, 0);
+    return {
+        name,
+        duration: totalDuration,
+        memoryBefore: memBefore,
+        memoryAfter: memAfter,
+        memoryDelta: memAfter - memBefore,
+        iterationCount: iterations,
+        averageTime: totalDuration / iterations,
+        averageMemory: (memAfter - memBefore) / iterations,
+        timestamp: new Date(),
+        metadata,
+    };
+}
+/**
+ * Compare benchmarks
+ */
+function compareBenchmarks(results, previous) {
+    const comparisons = [];
+    for (const current of results) {
+        const prev = previous.results.find((r) => r.name === current.name);
+        if (!prev) {
+            continue;
+        }
+        const timeChange = ((current.averageTime - prev.averageTime) / prev.averageTime) * 100;
+        const memChange = ((current.averageMemory - prev.averageMemory) / prev.averageMemory) * 100;
+        comparisons.push({
+            name: current.name,
+            timeChange,
+            memoryChange: memChange,
+            timeFaster: timeChange < 0,
+            memoryLower: memChange < 0,
+        });
+    }
+    return {
+        timestamp: new Date(),
+        comparisons,
+        overallImprovement: calculateOverallImprovement(comparisons),
+    };
+}
+/**
+ * Calculate overall improvement percentage
+ */
+function calculateOverallImprovement(comparisons) {
+    if (comparisons.length === 0) {
+        return 0;
+    }
+    const avgChange = comparisons.reduce((sum, c) => sum + c.timeChange, 0) / comparisons.length;
+    return -avgChange; // Negative change = improvement
+}
+/**
+ * Get results as formatted table
+ */
+function getFormattedTable(results) {
+    if (results.length === 0) {
+        return 'No benchmark results';
+    }
+    const rows = [
+        ['Operation', 'Iterations', 'Total (ms)', 'Avg (ms)', 'Memory Δ (KB)', 'Avg Mem (KB)'],
+        [
+            '-'.repeat(15),
+            '-'.repeat(11),
+            '-'.repeat(12),
+            '-'.repeat(10),
+            '-'.repeat(13),
+            '-'.repeat(13),
+        ],
+    ];
+    for (const result of results) {
+        rows.push([
+            result.name.padEnd(15),
+            result.iterationCount.toString().padEnd(11),
+            result.duration.toFixed(2).padEnd(12),
+            result.averageTime.toFixed(2).padEnd(10),
+            (result.memoryDelta / 1024).toFixed(1).padEnd(13),
+            (result.averageMemory / 1024).toFixed(1).padEnd(13),
+        ]);
+    }
+    return rows.map((row) => row.join(' ')).join('\n');
+}
+/**
+ * Get formatted comparison report
+ */
+function getFormattedComparisonReport(comparison) {
+    const lines = [
+        '=== Performance Comparison Report ===\n',
+        `Overall Improvement: ${comparison.overallImprovement > 0 ? '+' : ''}${comparison.overallImprovement.toFixed(1)}%\n`,
+        'Operation Comparisons:',
+        '-'.repeat(60),
+    ];
+    for (const comp of comparison.comparisons) {
+        const timeEmoji = comp.timeFaster ? '🟢' : '🔴';
+        const memEmoji = comp.memoryLower ? '🟢' : '🔴';
+        const timeLine = `${timeEmoji} ${comp.name}: ${comp.timeChange > 0 ? '+' : ''}${comp.timeChange.toFixed(1)}% time`;
+        const memLine = `${memEmoji} Memory: ${comp.memoryChange > 0 ? '+' : ''}${comp.memoryChange.toFixed(1)}% usage`;
+        lines.push(`\n${comp.name}`, `  Time: ${timeLine}`, `  ${memLine}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get benchmark suite as JSON
+ */
+function getBenchmarkSuite(name, startTime, results) {
+    const endTime = new Date();
+    const totalDuration = endTime.getTime() - startTime.getTime();
+    return {
+        name,
+        results: [...results],
+        totalDuration,
+        startTime,
+        endTime,
+    };
+}
+/**
+ * Memory Monitor - Track memory usage over time
+ * Sealed namespace for immutability
+ */
+export const MemoryMonitor = Object.freeze({
+    /**
+     * Create a new memory monitor instance
+     */
+    create() {
+        let snapshots = [];
+        let interval = null;
+        /**
+         * Format bytes as human-readable
+         */
+        const formatBytes = (bytes) => {
+            const units = ['B', 'KB', 'MB', 'GB'];
+            let size = bytes;
+            let unitIndex = 0;
+            while (size > 1024 && unitIndex < units.length - 1) {
+                size /= 1024;
+                unitIndex++;
+            }
+            return `${size.toFixed(2)} ${units[unitIndex]}`;
+        };
+        return {
+            /**
+             * Start monitoring
+             */
+            start(intervalMs = 100) {
+                if (interval) {
+                    clearInterval(interval);
+                }
+                snapshots = [];
+                const MAX_SNAPSHOTS = 10000; // Limit to 10,000 snapshots (~1MB)
+                interval = setInterval(() => {
+                    const mem = process.memoryUsage();
+                    snapshots.push({
+                        timestamp: Date.now(),
+                        heapUsed: mem.heapUsed,
+                        heapTotal: mem.heapTotal,
+                        external: mem.external,
+                        rss: mem.rss,
+                        arrayBuffers: mem.arrayBuffers || 0,
+                    });
+                    // Prevent unbounded growth
+                    if (snapshots.length > MAX_SNAPSHOTS) {
+                        snapshots.shift();
+                    }
+                }, intervalMs);
+            },
+            /**
+             * Stop monitoring
+             */
+            stop() {
+                if (interval) {
+                    clearInterval(interval);
+                    interval = null;
+                }
+                return [...snapshots];
+            },
+            /**
+             * Get memory statistics
+             */
+            getStats() {
+                return calculateMemoryStats(snapshots);
+            },
+            /**
+             * Format memory stats as string
+             */
+            formatStats() {
+                const stats = this.getStats();
+                return formatMemoryStats(stats, formatBytes);
+            },
+        };
+    },
+});
+/**
+ * Calculate memory statistics
+ */
+function calculateMemoryStats(snapshots) {
+    if (snapshots.length === 0) {
+        return {
+            peakHeap: 0,
+            minHeap: 0,
+            avgHeap: 0,
+            peakRss: 0,
+            snapshots: 0,
+        };
+    }
+    const heapUsages = snapshots.map((s) => s.heapUsed);
+    const rssUsages = snapshots.map((s) => s.rss);
+    return {
+        peakHeap: Math.max(...heapUsages),
+        minHeap: Math.min(...heapUsages),
+        avgHeap: heapUsages.reduce((a, b) => a + b, 0) / heapUsages.length,
+        peakRss: Math.max(...rssUsages),
+        snapshots: snapshots.length,
+    };
+}
+/**
+ * Format memory statistics
+ */
+function formatMemoryStats(stats, formatBytes) {
+    return [
+        'Memory Statistics:',
+        `  Peak Heap: ${formatBytes(stats.peakHeap)}`,
+        `  Min Heap: ${formatBytes(stats.minHeap)}`,
+        `  Avg Heap: ${formatBytes(stats.avgHeap)}`,
+        `  Peak RSS: ${formatBytes(stats.peakRss)}`,
+        `  Snapshots: ${stats.snapshots}`,
+    ].join('\n');
+}

package/src/performance/CodeGenerationBenchmark.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Code Generation Benchmarks
+ * Measure performance of all code generators
+ */
+export interface ICodeGenerationBenchmark {
+    runAll(): Promise<void>;
+    exportResults(filePath: string): void;
+}
+type CodeGenerationBenchmarkFn = {
+    (): ICodeGenerationBenchmark;
+    create: () => ICodeGenerationBenchmark;
+};
+/**
+ * CodeGenerationBenchmark - Benchmark all generators
+ * Sealed namespace for immutability
+ */
+export declare const CodeGenerationBenchmark: CodeGenerationBenchmarkFn;
+/**
+ * Run benchmarks
+ */
+export declare function runCodeGenerationBenchmarks(): Promise<void>;
+export {};
+//# sourceMappingURL=CodeGenerationBenchmark.d.ts.map

package/src/performance/CodeGenerationBenchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeGenerationBenchmark.d.ts","sourceRoot":"","sources":["../../../src/performance/CodeGenerationBenchmark.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,WAAW,wBAAwB;IACvC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,KAAK,yBAAyB,GAAG;IAC/B,IAAI,wBAAwB,CAAC;IAC7B,MAAM,EAAE,MAAM,wBAAwB,CAAC;CACxC,CAAC;AAgDF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,yBAmCG,CAAC;AAoL1C;;GAEG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAOjE"}

package/src/performance/CodeGenerationBenchmark.js

@@ -0,0 +1,249 @@
+/**
+ * Code Generation Benchmarks
+ * Measure performance of all code generators
+ */
+import { Logger } from '../config/logger';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+import { fs } from '../node-singletons/index.js';
+import { fileURLToPath } from '../node-singletons/url';
+import { Benchmark, MemoryMonitor } from './Benchmark';
+import * as path from 'node:path';
+function isBenchmarkFactory(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return typeof value.create === 'function';
+}
+function isBenchmarkConstructor(value) {
+    return typeof value === 'function';
+}
+function isMemoryMonitorFactory(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return typeof value.create === 'function';
+}
+function isMemoryMonitorConstructor(value) {
+    return typeof value === 'function';
+}
+function createBenchmark(name) {
+    const candidate = Benchmark;
+    if (isBenchmarkFactory(candidate))
+        return candidate.create(name);
+    if (isBenchmarkConstructor(candidate))
+        return new candidate(name);
+    throw ErrorFactory.createGeneralError('Benchmark export is neither a factory nor a constructor');
+}
+function createMemoryMonitor() {
+    const candidate = MemoryMonitor;
+    if (isMemoryMonitorFactory(candidate))
+        return candidate.create();
+    if (isMemoryMonitorConstructor(candidate))
+        return candidate();
+    throw ErrorFactory.createGeneralError('MemoryMonitor export is neither a factory nor a constructor');
+}
+/**
+ * CodeGenerationBenchmark - Benchmark all generators
+ * Sealed namespace for immutability
+ */
+export const CodeGenerationBenchmark = Object.freeze(Object.assign(() => {
+    const benchmark = createBenchmark('Code Generation Performance');
+    const memoryMonitor = createMemoryMonitor();
+    const testDir = path.join(process.cwd(), '.bench-output');
+    return {
+        async runAll() {
+            setup(testDir);
+            Logger.info('🏃 Running Code Generation Benchmarks...\n');
+            await benchmarkModelGeneration(benchmark, testDir);
+            await benchmarkControllerGeneration(benchmark, testDir);
+            await benchmarkMigrationGeneration(benchmark, testDir);
+            await benchmarkFactoryGeneration(benchmark, testDir);
+            await benchmarkSeederGeneration(benchmark, testDir);
+            await benchmarkBatchGeneration(benchmark, memoryMonitor);
+            Logger.info('\n' + benchmark.getTable());
+            cleanup(testDir);
+        },
+        exportResults(filePath) {
+            benchmark.export(filePath);
+            Logger.info(`✅ Benchmark results exported to: ${filePath}`);
+        },
+    };
+}, {
+    create: () => CodeGenerationBenchmark(),
+}));
+/**
+ * Setup test environment
+ */
+function setup(testDir) {
+    if (!fs.existsSync(testDir)) {
+        fs.mkdirSync(testDir, { recursive: true });
+    }
+}
+/**
+ * Cleanup test environment
+ */
+function cleanup(testDir) {
+    if (fs.existsSync(testDir)) {
+        fs.rmSync(testDir, { recursive: true });
+    }
+}
+/**
+ * Benchmark Model Generation
+ */
+async function benchmarkModelGeneration(benchmark, testDir) {
+    await benchmark.measureAsync('Model Generation', async () => {
+        const output = path.join(testDir, 'User.ts');
+        // Simulate model generation time with a small async operation
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    modelName: 'User',
+                    modelFile: output,
+                    message: 'Model generated successfully',
+                });
+            }, 8);
+        });
+    }, 10, { type: 'model', fields: 7 });
+}
+/**
+ * Benchmark Controller Generation
+ */
+async function benchmarkControllerGeneration(benchmark, testDir) {
+    await benchmark.measureAsync('Controller Generation', async () => {
+        const output = path.join(testDir, 'UserController.ts');
+        // Simulate controller generation time
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    controllerName: 'UserController',
+                    controllerFile: output,
+                    message: 'Controller generated successfully',
+                });
+            }, 6);
+        });
+    }, 10, { type: 'controller', actions: 5 });
+}
+/**
+ * Benchmark Migration Generation
+ */
+async function benchmarkMigrationGeneration(benchmark, testDir) {
+    await benchmark.measureAsync('Migration Generation', async () => {
+        const output = path.join(testDir, `${Date.now()}_create_users_table.ts`);
+        // Simulate migration generation time
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    migrationName: 'create_users_table',
+                    migrationFile: output,
+                    message: 'Migration generated successfully',
+                });
+            }, 7);
+        });
+    }, 10, { type: 'migration', columns: 4 });
+}
+/**
+ * Benchmark Factory Generation
+ */
+async function benchmarkFactoryGeneration(benchmark, testDir) {
+    await benchmark.measureAsync('Factory Generation', async () => {
+        const output = path.join(testDir, 'UserFactory.ts');
+        // Simulate factory generation time
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    factoryName: 'UserFactory',
+                    factoryFile: output,
+                    message: 'Factory generated successfully',
+                });
+            }, 5);
+        });
+    }, 10, { type: 'factory', fields: 3 });
+}
+/**
+ * Benchmark Seeder Generation
+ */
+async function benchmarkSeederGeneration(benchmark, testDir) {
+    await benchmark.measureAsync('Seeder Generation', async () => {
+        const output = path.join(testDir, 'UserSeeder.ts');
+        // Simulate seeder generation time
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    seederName: 'UserSeeder',
+                    seederFile: output,
+                    message: 'Seeder generated successfully',
+                });
+            }, 4);
+        });
+    }, 10, { type: 'seeder', count: 100 });
+}
+/**
+ * Benchmark Batch Generation (all generators together)
+ */
+async function benchmarkBatchGeneration(benchmark, memoryMonitor) {
+    memoryMonitor.start(50);
+    await benchmark.measureAsync('Full Feature Generation', async () => {
+        // Simulate batch generation of all components
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    components: 5,
+                    message: 'Full feature generated successfully',
+                });
+            }, 25);
+        });
+    }, 5, { type: 'batch', generators: 5 });
+    memoryMonitor.stop(); // Capture memory stats
+    // Use memory stats in formatStats calculation
+    Logger.info('\n' + memoryMonitor.formatStats());
+}
+/**
+ * Run benchmarks
+ */
+export async function runCodeGenerationBenchmarks() {
+    const benchmark = CodeGenerationBenchmark();
+    await benchmark.runAll();
+    // Export results
+    const resultsFile = path.join(process.cwd(), 'benchmark-results.json');
+    benchmark.exportResults(resultsFile);
+}
+// Run if called directly
+const isMain = (() => {
+    const override = globalThis
+        .__ZINTRUST_CODEGEN_BENCHMARK_MAIN__;
+    if (typeof override === 'boolean')
+        return override;
+    try {
+        const entrypoint = process.argv[1];
+        if (typeof entrypoint !== 'string')
+            return false;
+        const currentFilePath = fileURLToPath(new URL(import.meta.url));
+        // Use realpathSync to handle symlinks (common on macOS /var -> /private/var)
+        if (!('realpathSync' in fs)) {
+            return path.resolve(entrypoint) === path.resolve(currentFilePath);
+        }
+        try {
+            const realpathSync = fs
+                .realpathSync;
+            return realpathSync(entrypoint) === realpathSync(currentFilePath);
+        }
+        catch (err) {
+            Logger.error('❌ Baseline failed:', err);
+            return path.resolve(entrypoint) === path.resolve(currentFilePath);
+        }
+    }
+    catch (err) {
+        Logger.error('❌ Baseline failed:', err);
+        return false;
+    }
+})();
+if (isMain) {
+    await runCodeGenerationBenchmarks().catch((err) => {
+        Logger.error('Benchmark failed:', err);
+        process.exit(1);
+    });
+}

package/src/performance/Optimizer.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Performance Optimizations for Code Generation
+ * Implements caching, lazy-loading, and parallel generation
+ */
+export interface IGenerationCache {
+    get(type: string, params: Record<string, unknown>): string | null;
+    set(type: string, params: Record<string, unknown>, code: string): void;
+    save(): void;
+    clear(): void;
+    getStats(): {
+        size: number;
+        entries: number;
+        diskUsage: string;
+        keys: string[];
+    };
+}
+/**
+ * Generation Cache - Cache generated code to avoid re-generating identical code
+ * Sealed namespace for immutability
+ */
+export declare const GenerationCache: Readonly<{
+    /**
+     * Create a new generation cache instance
+     */
+    create(cacheDir?: string, ttlMs?: number): IGenerationCache;
+}>;
+export interface ILazyLoader {
+    load<T>(modulePath: string): Promise<T>;
+    preload(modulePaths: string[]): Promise<void>;
+    clear(): void;
+}
+/**
+ * Lazy Module Loader - Load dependencies only when needed
+ * Sealed namespace for immutability
+ */
+export declare const LazyLoader: Readonly<{
+    /**
+     * Create a new lazy loader instance
+     */
+    create(): ILazyLoader;
+}>;
+/**
+ * Parallel Generator - Run multiple generators in parallel
+ */
+/**
+ * Run generators in parallel batches
+ */
+export declare function runBatch<T>(generators: Array<() => Promise<T>>, batchSize?: number): Promise<T[]>;
+/**
+ * Run all generators in parallel
+ */
+export declare function runAll<T>(generators: Array<() => Promise<T>>): Promise<T[]>;
+export declare const ParallelGenerator: Readonly<{
+    runBatch: typeof runBatch;
+    runAll: typeof runAll;
+}>;
+/**
+ * Memoize - Cache function results based on arguments
+ */
+/**
+ * Create a memoized version of a function
+ */
+export declare function createMemoized<T extends (...args: any[]) => any>(fn: T, options?: {
+    ttl?: number;
+    keyGenerator?: (args: Parameters<T>) => string;
+}): T;
+export declare const Memoize: Readonly<{
+    create: typeof createMemoized;
+}>;
+export interface IPerformanceOptimizer {
+    generateWithCache<T>(type: string, params: Record<string, unknown>, generatorFn: () => Promise<T>): Promise<T>;
+    generateInParallel<T>(generators: Array<() => Promise<T>>, batchSize?: number): Promise<T[]>;
+    preloadModules(paths: string[]): Promise<void>;
+    getStats(): {
+        cacheHits: number;
+        cacheMisses: number;
+        hitRate: string;
+        parallelRuns: number;
+        estimatedSavedTime: string;
+        cacheStatus: {
+            size: number;
+            keys: string[];
+        };
+    };
+    saveCache(): void;
+    clear(): void;
+}
+/**
+ * Performance Optimizer - Wrapper for optimizations
+ * Sealed namespace for immutability
+ */
+export declare const PerformanceOptimizer: Readonly<{
+    /**
+     * Create a new performance optimizer instance
+     */
+    create(): IPerformanceOptimizer;
+}>;
+export default PerformanceOptimizer;
+//# sourceMappingURL=Optimizer.d.ts.map

package/src/performance/Optimizer.d.ts.map

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