@zintrust/core 0.1.0

package/src/cli/debug/Dashboard.js

@@ -0,0 +1,152 @@
+/**
+ * Debug Dashboard
+ * Terminal-based real-time monitoring UI
+ */
+import { randomInt } from '../../node-singletons/crypto';
+import * as os from '../../node-singletons/os';
+import * as readline from '../../node-singletons/readline';
+import chalk from 'chalk';
+const formatBytes = (bytes) => {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes;
+    let i = 0;
+    while (size > 1024 && i < units.length - 1) {
+        size /= 1024;
+        i++;
+    }
+    return `${size.toFixed(2)} ${units[i]}`;
+};
+const formatDuration = (seconds) => {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = Math.floor(seconds % 60);
+    return `${h}h ${m}m ${s}s`;
+};
+const getPercent = (value, total) => {
+    return ((value / total) * 100).toFixed(1);
+};
+const hideCursor = () => {
+    process.stdout.write('\x1B[?25l');
+};
+const showCursor = () => {
+    process.stdout.write('\x1B[?25h');
+};
+const renderSection = (title, lines) => {
+    process.stdout.write(chalk.cyan.bold(`\n[ ${title} ]`) + '\n');
+    lines.forEach((line) => process.stdout.write(`  ${line}\n`));
+};
+const render = (stats) => {
+    readline.cursorTo(process.stdout, 0, 0);
+    const header = chalk.bgBlue.white.bold(' ZINTRUST DEBUG DASHBOARD ');
+    const uptime = chalk.gray(`Uptime: ${formatDuration(stats.uptime)}`);
+    process.stdout.write(`${header} ${uptime}\n\n`);
+    renderSection('SYSTEM RESOURCES', [
+        `Memory: ${formatBytes(stats.memory.used)} / ${formatBytes(stats.memory.total)} (${getPercent(stats.memory.used, stats.memory.total)}%)`,
+        `CPU Load: ${os.loadavg()[0].toFixed(2)}`,
+    ]);
+    renderSection('HTTP REQUESTS', [
+        `Total Requests: ${stats.requests.total}`,
+        `Active Requests: ${chalk.green(stats.requests.active)}`,
+        `Avg Duration: ${stats.requests.avgDuration}ms`,
+    ]);
+    renderSection('DATABASE QUERIES', [
+        `Total Queries: ${stats.queries.total}`,
+        `N+1 Warnings: ${stats.queries.n1Warnings > 0 ? chalk.red.bold(stats.queries.n1Warnings) : chalk.green('0')}`,
+    ]);
+    process.stdout.write('\n' + chalk.gray('Press Ctrl+C to exit') + '\n');
+};
+const updateStatsInternal = (stats) => {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    stats.uptime = process.uptime();
+    stats.memory = {
+        total: totalMem,
+        free: freeMem,
+        used: totalMem - freeMem,
+    };
+    // Mock some activity for demonstration
+    if (randomInt(0, 1000) > 700) {
+        stats.requests.total += randomInt(0, 3);
+        stats.requests.active = randomInt(0, 5);
+        stats.requests.avgDuration = randomInt(20, 120);
+    }
+    if (randomInt(0, 1000) > 800) {
+        stats.queries.total += randomInt(0, 10);
+        if (randomInt(0, 1000) > 900) {
+            stats.queries.n1Warnings++;
+        }
+    }
+};
+/**
+ * Debug Dashboard
+ * Terminal-based real-time monitoring UI
+ * Sealed namespace for immutability
+ */
+const DashboardFactory = Object.freeze({
+    create() {
+        const state = {
+            rl: readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            }),
+            stats: {
+                uptime: 0,
+                memory: { total: 0, free: 0, used: 0 },
+                requests: { total: 0, active: 0, avgDuration: 0 },
+                queries: { total: 0, n1Warnings: 0 },
+            },
+            timer: undefined,
+        };
+        const dashboard = {
+            render() {
+                render(state.stats);
+            },
+            updateStats() {
+                updateStatsInternal(state.stats);
+            },
+            /**
+             * Start the dashboard
+             */
+            start() {
+                process.stdout.write('\x1Bc'); // Clear screen
+                hideCursor();
+                dashboard.render();
+                if (state.timer) {
+                    clearInterval(state.timer);
+                }
+                state.timer = setInterval(() => {
+                    dashboard.updateStats();
+                    dashboard.render();
+                }, 1000);
+                // Ensure cleanup on exit
+                const cleanup = () => {
+                    dashboard.stop();
+                    process.exit(0);
+                };
+                process.on('SIGINT', cleanup);
+                process.on('SIGTERM', cleanup);
+            },
+            /**
+             * Stop the dashboard
+             */
+            stop() {
+                if (state.timer) {
+                    clearInterval(state.timer);
+                }
+                showCursor();
+                state.rl.close();
+            },
+            /**
+             * Update dashboard stats
+             */
+            update(newStats) {
+                state.stats = { ...state.stats, ...newStats };
+            },
+        };
+        return dashboard;
+    },
+});
+const DashboardCallable = function DashboardCallable() {
+    return DashboardFactory.create();
+};
+export const Dashboard = Object.assign(DashboardCallable, DashboardFactory);

package/src/cli/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI Module Index
+ * Exports all CLI components
+ */
+export { BaseCommand, type CommandOptions } from './BaseCommand';
+export { CLI } from './CLI';
+export { EXIT_CODES, ErrorHandler } from './ErrorHandler';
+export { PromptHelper, type PromptOptions } from './PromptHelper';
+export { AddCommand } from './commands/AddCommand';
+export { ConfigCommand } from './commands/ConfigCommand';
+export { DebugCommand } from './commands/DebugCommand';
+export { MigrateCommand } from './commands/MigrateCommand';
+export { NewCommand } from './commands/NewCommand';
+//# sourceMappingURL=index.d.ts.map

package/src/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGrE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC"}

package/src/cli/index.js

@@ -0,0 +1,14 @@
+/**
+ * CLI Module Index
+ * Exports all CLI components
+ */
+export { BaseCommand } from './BaseCommand';
+export { CLI } from './CLI';
+export { EXIT_CODES, ErrorHandler } from './ErrorHandler';
+export { PromptHelper } from './PromptHelper';
+// Export commands
+export { AddCommand } from './commands/AddCommand';
+export { ConfigCommand } from './commands/ConfigCommand';
+export { DebugCommand } from './commands/DebugCommand';
+export { MigrateCommand } from './commands/MigrateCommand';
+export { NewCommand } from './commands/NewCommand';

package/src/cli/logger/Logger.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Logger - File-Based Logging System
+ * Logs to files with rotation, retention policies, and multiple log levels
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    context?: string;
+    data?: Record<string, unknown>;
+}
+export interface LoggerInstance {
+    debug(message: string, data?: Record<string, unknown>, category?: string): void;
+    info(message: string, data?: Record<string, unknown>, category?: string): void;
+    warn(message: string, data?: Record<string, unknown>, category?: string): void;
+    error(message: string, data?: Record<string, unknown>, category?: string): void;
+    getLogs(category?: string, limit?: number): LogEntry[];
+    filterByLevel(logs: LogEntry[], level: LogLevel): LogEntry[];
+    filterByDateRange(logs: LogEntry[], startDate: Date, endDate: Date): LogEntry[];
+    clearLogs(category?: string): boolean;
+    getLogsDirectory(): string;
+    getLogLevel(): LogLevel;
+}
+export declare const Logger: Readonly<{
+    /**
+     * Create a new logger instance
+     */
+    create(logsDir?: string, maxFileSize?: number, level?: LogLevel): LoggerInstance;
+    /**
+     * Get singleton instance
+     */
+    getInstance(): LoggerInstance;
+    debug(message: string, data?: Record<string, unknown>, category?: string): void;
+    info(message: string, data?: Record<string, unknown>, category?: string): void;
+    warn(message: string, data?: Record<string, unknown>, category?: string): void;
+    error(message: string, data?: Record<string, unknown>, category?: string): void;
+}>;
+declare global {
+    var __loggerInstance: LoggerInstance | undefined;
+}
+export default Logger;
+//# sourceMappingURL=Logger.d.ts.map

package/src/cli/logger/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../../../src/cli/logger/Logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChF,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/E,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/E,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChF,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IACvD,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAC;IAC7D,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,GAAG,QAAQ,EAAE,CAAC;IAChF,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACtC,gBAAgB,IAAI,MAAM,CAAC;IAC3B,WAAW,IAAI,QAAQ,CAAC;CACzB;AAsED,eAAO,MAAM,MAAM;IACjB;;OAEG;qBAEQ,MAAM,gBACF,MAAM,UACZ,QAAQ,GACd,cAAc;IAyDjB;;OAEG;mBACY,cAAc;mBAMd,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,MAAM,GAAG,IAAI;kBAGjE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,MAAM,GAAG,IAAI;kBAGhE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,MAAM,GAAG,IAAI;mBAG/D,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,MAAM,GAAG,IAAI;EAG/E,CAAC;AAGH,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,gBAAgB,EAAE,cAAc,GAAG,SAAS,CAAC;CAClD;AAED,eAAe,MAAM,CAAC"}

package/src/cli/logger/Logger.js

@@ -0,0 +1,137 @@
+/**
+ * Logger - File-Based Logging System
+ * Logs to files with rotation, retention policies, and multiple log levels
+ */
+import * as fs from '../../node-singletons/fs';
+import * as path from '../../node-singletons/path';
+const levelPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+const ensureLogsDir = (logsDir) => {
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+};
+const getLogFilePath = (logsDir, category = 'app') => {
+    return path.join(logsDir, `${category}.log`);
+};
+const writeToLogFile = (logsDir, maxFileSize, entry, category = 'app') => {
+    ensureLogsDir(logsDir);
+    const logFile = getLogFilePath(logsDir, category);
+    const logString = JSON.stringify(entry) + '\n';
+    try {
+        // Check file size for rotation
+        if (fs.existsSync(logFile)) {
+            const stats = fs.statSync(logFile);
+            if (stats.size > maxFileSize) {
+                const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
+                fs.renameSync(logFile, `${logFile}.${timestamp}.bak`);
+            }
+        }
+        fs.appendFileSync(logFile, logString);
+    }
+    catch (error) {
+        // Fallback to stderr if file logging fails
+        process.stderr.write(`Failed to write to log file: ${String(error)}\n`);
+    }
+};
+const log = (logsDir, maxFileSize, currentLevel, logLevel, message, data, category = 'app') => {
+    if (levelPriority[logLevel] < levelPriority[currentLevel]) {
+        return;
+    }
+    const entry = {
+        timestamp: new Date().toISOString(),
+        level: logLevel,
+        message,
+        data,
+        context: category,
+    };
+    writeToLogFile(logsDir, maxFileSize, entry, category);
+};
+export const Logger = Object.freeze({
+    /**
+     * Create a new logger instance
+     */
+    create(logsDir = path.join(process.cwd(), 'logs'), maxFileSize = 10 * 1024 * 1024, // 10MB
+    level = 'info') {
+        return {
+            debug(message, data, category) {
+                log(logsDir, maxFileSize, level, 'debug', message, data, category);
+            },
+            info(message, data, category) {
+                log(logsDir, maxFileSize, level, 'info', message, data, category);
+            },
+            warn(message, data, category) {
+                log(logsDir, maxFileSize, level, 'warn', message, data, category);
+            },
+            error(message, data, category) {
+                log(logsDir, maxFileSize, level, 'error', message, data, category);
+            },
+            getLogs(category = 'app', limit = 100) {
+                const logFile = getLogFilePath(logsDir, category);
+                if (!fs.existsSync(logFile))
+                    return [];
+                try {
+                    const content = fs.readFileSync(logFile, 'utf-8');
+                    return content
+                        .split('\n')
+                        .filter((line) => line.trim() !== '')
+                        .map((line) => JSON.parse(line))
+                        .reverse()
+                        .slice(0, limit);
+                }
+                catch (error) {
+                    process.stderr.write(`Failed to read logs: ${String(error)}\n`);
+                    return [];
+                }
+            },
+            filterByLevel(logs, filterLevel) {
+                return logs.filter((l) => l.level === filterLevel);
+            },
+            filterByDateRange(logs, startDate, endDate) {
+                return logs.filter((l) => {
+                    const date = new Date(l.timestamp);
+                    return date >= startDate && date <= endDate;
+                });
+            },
+            clearLogs(category = 'app') {
+                const logFile = getLogFilePath(logsDir, category);
+                if (fs.existsSync(logFile)) {
+                    fs.unlinkSync(logFile);
+                    return true;
+                }
+                return false;
+            },
+            getLogsDirectory() {
+                return logsDir;
+            },
+            getLogLevel() {
+                return level;
+            },
+        };
+    },
+    /**
+     * Get singleton instance
+     */
+    getInstance() {
+        globalThis.__loggerInstance ??= this.create();
+        return globalThis.__loggerInstance;
+    },
+    // Static-like methods for convenience
+    debug(message, data, category) {
+        this.getInstance().debug(message, data, category);
+    },
+    info(message, data, category) {
+        this.getInstance().info(message, data, category);
+    },
+    warn(message, data, category) {
+        this.getInstance().warn(message, data, category);
+    },
+    error(message, data, category) {
+        this.getInstance().error(message, data, category);
+    },
+});
+export default Logger;

package/src/cli/scaffolding/ControllerGenerator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ControllerGenerator - Generate controller files
+ * Creates CRUD controllers with validation and error handling
+ */
+export type ControllerType = 'crud' | 'resource' | 'api' | 'graphql' | 'websocket' | 'webhook';
+export interface ControllerOptions {
+    name: string;
+    controllerPath: string;
+    type?: ControllerType;
+    model?: string;
+    methods?: string[];
+    withValidation?: boolean;
+    withErrorHandling?: boolean;
+}
+export interface ControllerGeneratorResult {
+    success: boolean;
+    controllerName: string;
+    controllerFile: string;
+    message: string;
+}
+/**
+ * Validate controller options
+ */
+export declare function validateOptions(options: ControllerOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate controller file
+ */
+export declare function generateController(options: ControllerOptions): Promise<ControllerGeneratorResult>;
+/**
+ * Get available controller types
+ */
+export declare function getAvailableTypes(): ControllerType[];
+/**
+ * ControllerGenerator creates HTTP request handlers
+ */
+export declare const ControllerGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateController: typeof generateController;
+    getAvailableTypes: typeof getAvailableTypes;
+}>;
+//# sourceMappingURL=ControllerGenerator.d.ts.map

package/src/cli/scaffolding/ControllerGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ControllerGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/ControllerGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC;AAE/F,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAcD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAgChG;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,yBAAyB,CAAC,CA2CpC;AA6cD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,EAAE,CAEpD;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC"}