@zintrust/core 0.1.0

package/bin/z.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI Shortcut - 'z'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+import './zintrust';
+//# sourceMappingURL=z.d.ts.map

package/bin/z.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"z.d.ts","sourceRoot":"","sources":["../../bin/z.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,YAAY,CAAC"}

package/bin/z.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI Shortcut - 'z'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+import './zintrust';

package/bin/zin.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI Shortcut - 'zin'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+import './zintrust';
+//# sourceMappingURL=zin.d.ts.map

package/bin/zin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zin.d.ts","sourceRoot":"","sources":["../../bin/zin.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,YAAY,CAAC"}

package/bin/zin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI Shortcut - 'zin'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+import './zintrust';

package/bin/zintrust-microservices.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Zintrust Microservices CLI
+ * Commands for generating, bundling, and managing microservices
+ */
+export {};
+//# sourceMappingURL=zintrust-microservices.d.ts.map

package/bin/zintrust-microservices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zintrust-microservices.d.ts","sourceRoot":"","sources":["../../bin/zintrust-microservices.ts"],"names":[],"mappings":";AAEA;;;GAGG"}

package/bin/zintrust-microservices.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Zintrust Microservices CLI
+ * Commands for generating, bundling, and managing microservices
+ */
+import { Logger } from '../src/config/logger';
+import { MicroserviceGenerator } from '../src/microservices/MicroserviceGenerator';
+import { MicroserviceManager } from '../src/microservices/MicroserviceManager';
+import { ServiceBundler } from '../src/microservices/ServiceBundler';
+import { readFileSync } from '../src/node-singletons/fs';
+import { dirname, join } from '../src/node-singletons/path';
+import { fileURLToPath } from '../src/node-singletons/url';
+import { program } from 'commander';
+const getStringOption = (options, key, fallback) => {
+    const value = options[key];
+    return typeof value === 'string' && value.trim() !== '' ? value : fallback;
+};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Version
+const packageJsonUnknown = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const packageVersion = typeof packageJsonUnknown === 'object' &&
+    packageJsonUnknown !== null &&
+    'version' in packageJsonUnknown &&
+    typeof packageJsonUnknown.version === 'string'
+    ? packageJsonUnknown.version
+    : '0.0.0';
+program.version(packageVersion);
+/**
+ * Generate microservices
+ */
+program
+    .command('generate <domain> <services>')
+    .description('Generate microservices scaffold')
+    .option('--port <port>', 'Base port for services', '3001')
+    .option('--version <version>', 'Service version', '1.0.0')
+    .action(async (domain, services, options) => {
+    try {
+        const serviceList = services.split(',').map((s) => s.trim());
+        const portRaw = getStringOption(options, 'port', '3001');
+        const version = getStringOption(options, 'version', '1.0.0');
+        await MicroserviceGenerator.getInstance().generate({
+            domain,
+            services: serviceList,
+            basePort: Number.parseInt(portRaw, 10),
+            version,
+        });
+        Logger.info('Microservices generated successfully');
+    }
+    catch (error) {
+        Logger.error('Error generating microservices:', error);
+        process.exit(1);
+    }
+});
+/**
+ * Bundle services
+ */
+program
+    .command('bundle <domain> <services>')
+    .description('Bundle microservices for deployment')
+    .option('--output <dir>', 'Output directory', 'dist/services')
+    .option('--target-size <mb>', 'Target bundle size in MB', '1')
+    .action(async (domain, services, options) => {
+    try {
+        const serviceList = services.split(',').map((s) => s.trim());
+        const outputDir = getStringOption(options, 'output', 'dist/services');
+        const results = await ServiceBundler.getInstance().bundleAll(domain, serviceList, outputDir);
+        const allOptimized = results.every((r) => r.optimized === true);
+        if (allOptimized === false) {
+            Logger.warn('Some services exceed target size. Consider optimizing bundle.');
+        }
+    }
+    catch (error) {
+        Logger.error('Error bundling microservices:', error);
+        process.exit(1);
+    }
+});
+/**
+ * Create Docker images
+ */
+program
+    .command('docker <domain> <services>')
+    .description('Create Docker images for services')
+    .option('--registry <url>', 'Docker registry URL', 'localhost:5000')
+    .action(async (domain, services, options) => {
+    try {
+        const serviceList = services.split(',').map((s) => s.trim());
+        const registry = getStringOption(options, 'registry', 'localhost:5000');
+        await Promise.all(serviceList.map((service) => ServiceBundler.getInstance().createServiceImage(service, domain, registry)));
+        Logger.info(`Docker images ready. Build with:\n  docker-compose -f services/${domain}/docker-compose.yml build`);
+    }
+    catch (error) {
+        Logger.error('Error creating Docker images:', error);
+        process.exit(1);
+    }
+});
+/**
+ * Discover services
+ */
+program
+    .command('discover')
+    .description('Discover available microservices')
+    .action(async () => {
+    try {
+        const configs = await MicroserviceManager.discoverServices();
+        if (configs.length === 0) {
+            Logger.info('No microservices found in services/ folder');
+            return;
+        }
+        Logger.info(`Found ${configs.length} microservice(s):`);
+        for (const config of configs) {
+            const version = config.version !== undefined && config.version !== null && config.version !== ''
+                ? config.version
+                : '1.0.0';
+            Logger.info(`  • ${config.name} (${config.domain}) - v${version}`);
+            if (config.dependencies !== undefined &&
+                config.dependencies !== null &&
+                config.dependencies.length > 0) {
+                Logger.info(`    Dependencies: ${config.dependencies.join(', ')}`);
+            }
+        }
+    }
+    catch (error) {
+        Logger.error('Error discovering services:', error);
+        process.exit(1);
+    }
+});
+/**
+ * Status of services
+ */
+program
+    .command('status')
+    .description('Check status of running microservices')
+    .action(async () => {
+    try {
+        const manager = MicroserviceManager.getInstance();
+        const summary = manager.getStatusSummary();
+        Logger.info(`Microservices Status:\n${JSON.stringify(summary, null, 2)}`);
+    }
+    catch (error) {
+        Logger.error('Error getting microservices status:', error);
+        process.exit(1);
+    }
+});
+/**
+ * Health check
+ */
+program
+    .command('health')
+    .description('Health check all services')
+    .action(async () => {
+    try {
+        const manager = MicroserviceManager.getInstance();
+        const results = await manager.healthCheckAll();
+        Logger.info('Health Check Results');
+        for (const [service, healthy] of Object.entries(results)) {
+            Logger.info(`  ${service}: ${healthy ? 'Healthy' : 'Unhealthy'}`);
+        }
+    }
+    catch (error) {
+        Logger.error('Error performing health check:', error);
+        process.exit(1);
+    }
+});
+program.parse(process.argv);

package/bin/zintrust.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI - Main Entry Point
+ * Command-line interface for Zintrust framework
+ * Usage: zintrust [command] [options]
+ * Shortcuts: zin, z
+ */
+export {};
+//# sourceMappingURL=zintrust.d.ts.map

package/bin/zintrust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zintrust.d.ts","sourceRoot":"","sources":["../../bin/zintrust.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AA8CH,OAAO,EAAE,CAAC"}

package/bin/zintrust.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI - Main Entry Point
+ * Command-line interface for Zintrust framework
+ * Usage: zintrust [command] [options]
+ * Shortcuts: zin, z
+ */
+async function main() {
+    try {
+        const { EnvFileLoader } = await import('../src/cli/utils/EnvFileLoader');
+        EnvFileLoader.ensureLoaded();
+        const { CLI } = await import('../src/cli/CLI');
+        const cli = CLI.create();
+        await cli.run(process.argv.slice(2));
+    }
+    catch (error) {
+        try {
+            const { Logger } = await import('../src/config/logger');
+            Logger.error('CLI execution failed', error);
+        }
+        catch {
+            // best-effort logging
+        }
+        try {
+            const { ErrorHandler } = await import('../src/cli/ErrorHandler');
+            ErrorHandler.handle(error);
+        }
+        catch {
+            // best-effort error handling
+        }
+        process.exit(1);
+    }
+}
+await main().catch(async (error) => {
+    try {
+        const { Logger } = await import('../src/config/logger');
+        Logger.error('CLI fatal error', error);
+    }
+    catch {
+        // best-effort logging
+    }
+    try {
+        const { ErrorHandler } = await import('../src/cli/ErrorHandler');
+        ErrorHandler.handle(error);
+    }
+    catch {
+        // best-effort error handling
+    }
+    process.exit(1);
+});
+export {};

package/bin/zt.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI Shortcut - 'z'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+import './zintrust';
+//# sourceMappingURL=zt.d.ts.map

package/bin/zt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zt.d.ts","sourceRoot":"","sources":["../../bin/zt.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,YAAY,CAAC"}

package/bin/zt.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Zintrust CLI Shortcut - 'z'
+ * Mirrors bin/zintrust.ts for convenience
+ */
+import './zintrust';

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@zintrust/core",
+  "version": "0.1.0",
+  "description": "Production-grade TypeScript backend framework for JavaScript",
+  "homepage": "https://zintrust.com",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZinTrust/ZinTrust.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ZinTrust/ZinTrust/issues"
+  },
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "bin": {
+    "zintrust": "bin/zintrust.js",
+    "zin": "bin/zin.js",
+    "z": "bin/z.js",
+    "zt": "bin/zt.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=20.0.0",
+    "npm": ">=9.0.0"
+  },
+  "keywords": [
+    "framework",
+    "typescript",
+    "backend",
+    "orm",
+    "query-builder",
+    "rest-api",
+    "react",
+    "react-api",
+    "vue",
+    "vue-api",
+    "symfony",
+    "laravel"
+  ],
+  "author": "Zintrust Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "bcrypt": "^6.0.0",
+    "better-sqlite3": "^12.5.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "inquirer": "^13.1.0",
+    "jsonwebtoken": "^9.0.3",
+    "tsx": "^4.21.0"
+  },
+  "devDependencies": {
+    "@codecov/vite-plugin": "^1.9.1",
+    "@resvg/resvg-js": "^2.6.2",
+    "@types/bcrypt": "^6.0.0",
+    "@types/better-sqlite3": "7.6.13",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/parser": "^8.50.0",
+    "@vitest/coverage-v8": "^4.0.16",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "sonarqube-scanner": "^4.3.2",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.50.0",
+    "vitest": "^4.0.16"
+  }
+}

package/src/boot/Application.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Application - Framework core entry point
+ * Handles application lifecycle, booting, and environment
+ */
+import { IServiceContainer } from '../container/ServiceContainer';
+import { IMiddlewareStack } from '../middleware/MiddlewareStack';
+import { type IRouter } from '../routing/Router';
+export interface IApplication {
+    boot(): Promise<void>;
+    shutdown(): Promise<void>;
+    isBooted(): boolean;
+    isDevelopment(): boolean;
+    isProduction(): boolean;
+    isTesting(): boolean;
+    getEnvironment(): string;
+    getRouter(): IRouter;
+    getContainer(): IServiceContainer;
+    getMiddlewareStack(): IMiddlewareStack;
+    getBasePath(): string;
+}
+/**
+ * Application Factory
+ */
+export declare const Application: Readonly<{
+    /**
+     * Create a new application instance
+     */
+    create(basePath?: string): IApplication;
+}>;
+export default Application;
+//# sourceMappingURL=Application.d.ts.map

package/src/boot/Application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Application.d.ts","sourceRoot":"","sources":["../../../src/boot/Application.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAoB,MAAM,8BAA8B,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAmB,MAAM,8BAA8B,CAAC;AACjF,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,kBAAkB,CAAC;AAMxD,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,QAAQ,IAAI,OAAO,CAAC;IACpB,aAAa,IAAI,OAAO,CAAC;IACzB,YAAY,IAAI,OAAO,CAAC;IACxB,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,IAAI,MAAM,CAAC;IACzB,SAAS,IAAI,OAAO,CAAC;IACrB,YAAY,IAAI,iBAAiB,CAAC;IAClC,kBAAkB,IAAI,gBAAgB,CAAC;IACvC,WAAW,IAAI,MAAM,CAAC;CACvB;AAqJD;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;sBACe,MAAM,GAAG,YAAY;EAwCvC,CAAC;AAEH,eAAe,WAAW,CAAC"}

package/src/boot/Application.js

@@ -0,0 +1,159 @@
+/**
+ * Application - Framework core entry point
+ * Handles application lifecycle, booting, and environment
+ */
+import { ServiceContainer } from '../container/ServiceContainer';
+import { MiddlewareStack } from '../middleware/MiddlewareStack';
+import { Router } from '../routing/Router';
+import { Env } from '../config/env';
+import { Logger } from '../config/logger';
+import * as path from '../node-singletons/path';
+import { pathToFileURL } from '../node-singletons/url';
+const ShutdownManager = Object.freeze({
+    create() {
+        const hooks = [];
+        return Object.freeze({
+            add(hook) {
+                hooks.push(hook);
+            },
+            async run() {
+                for (const hook of hooks) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await hook();
+                }
+            },
+        });
+    },
+});
+const resolveBasePath = (basePath) => {
+    if (typeof basePath === 'string')
+        return basePath;
+    if (typeof process !== 'undefined' && typeof process.cwd === 'function')
+        return process.cwd();
+    return '';
+};
+const makeJoinFromBase = (resolvedBasePath) => (subPath) => {
+    return resolvedBasePath.length > 0 ? `${resolvedBasePath}/${subPath}` : subPath;
+};
+const registerCorePaths = (container, resolvedBasePath, joinFromBase) => {
+    container.singleton('paths', {
+        base: resolvedBasePath,
+        app: joinFromBase('app'),
+        config: joinFromBase('config'),
+        database: joinFromBase('database'),
+        routes: joinFromBase('routes'),
+        tests: joinFromBase('tests'),
+    });
+};
+const registerCoreInstances = (params) => {
+    params.container.singleton('env', params.environment);
+    params.container.singleton('router', params.router);
+    params.container.singleton('middleware', params.middlewareStack);
+    params.container.singleton('container', params.container);
+    params.container.singleton('shutdownManager', params.shutdownManager);
+};
+const tryImportRoutesFromAppBase = async (resolvedBasePath) => {
+    if (resolvedBasePath === '')
+        return undefined;
+    const candidates = [
+        // Dev (tsx)
+        path.join(resolvedBasePath, 'routes', 'api.ts'),
+        // Production build output
+        path.join(resolvedBasePath, 'dist', 'routes', 'api.js'),
+        // Fallback (in case someone transpiles without /dist)
+        path.join(resolvedBasePath, 'routes', 'api.js'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const url = pathToFileURL(candidate).href;
+            // eslint-disable-next-line no-await-in-loop
+            return (await import(url));
+        }
+        catch {
+            // keep trying
+        }
+    }
+    return undefined;
+};
+const registerRoutes = async (resolvedBasePath, router) => {
+    try {
+        const mod = await tryImportRoutesFromAppBase(resolvedBasePath);
+        if (typeof mod?.registerRoutes === 'function') {
+            mod.registerRoutes(router);
+            return;
+        }
+        const { registerRoutes: registerFrameworkRoutes } = await import('../../routes/api');
+        registerFrameworkRoutes(router);
+    }
+    catch (error) {
+        Logger.error('Failed to register routes:', error);
+    }
+};
+const createLifecycle = (params) => {
+    const boot = async () => {
+        if (params.getBooted())
+            return;
+        Logger.info(`🚀 Booting Zintrust Application in ${params.environment} mode...`);
+        await registerRoutes(params.resolvedBasePath, params.router);
+        // Register service providers
+        // Bootstrap services
+        params.setBooted(true);
+        Logger.info('✅ Application booted successfully');
+    };
+    const shutdown = async () => {
+        Logger.info('🛑 Shutting down application...');
+        try {
+            await params.shutdownManager.run();
+        }
+        catch (error) {
+            Logger.error('Shutdown hook failed:', error);
+        }
+        Logger.info('✅ Application shut down successfully');
+        params.setBooted(false);
+    };
+    return { boot, shutdown };
+};
+/**
+ * Application Factory
+ */
+export const Application = Object.freeze({
+    /**
+     * Create a new application instance
+     */
+    create(basePath) {
+        const resolvedBasePath = resolveBasePath(basePath);
+        const joinFromBase = makeJoinFromBase(resolvedBasePath);
+        const environment = Env.get('NODE_ENV', 'development');
+        const container = ServiceContainer.create();
+        const router = Router.createRouter();
+        const middlewareStack = MiddlewareStack.create();
+        const shutdownManager = ShutdownManager.create();
+        let booted = false;
+        registerCorePaths(container, resolvedBasePath, joinFromBase);
+        registerCoreInstances({ container, environment, router, middlewareStack, shutdownManager });
+        const { boot, shutdown } = createLifecycle({
+            environment,
+            resolvedBasePath,
+            router,
+            shutdownManager,
+            getBooted: () => booted,
+            setBooted: (value) => {
+                booted = value;
+            },
+        });
+        return {
+            boot,
+            shutdown,
+            isBooted: () => booted,
+            isDevelopment: () => environment === 'development',
+            isProduction: () => environment === 'production',
+            isTesting: () => environment === 'testing' || environment === 'test',
+            getEnvironment: () => environment,
+            getRouter: () => router,
+            getContainer: () => container,
+            getMiddlewareStack: () => middlewareStack,
+            getBasePath: () => resolvedBasePath,
+        };
+    },
+});
+export default Application;

package/src/boot/Server.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Server - HTTP Server implementation
+ * Uses Node.js built-in HTTP server with no external dependencies
+ */
+import { IApplication } from './Application';
+import * as http from '../node-singletons/http';
+export interface IServer {
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    getHttpServer(): http.Server;
+}
+/**
+ * Server - HTTP Server implementation
+ * Refactored to Functional Object pattern
+ */
+export declare const Server: Readonly<{
+    /**
+     * Create a new server instance
+     */
+    create(app: IApplication, port?: number, host?: string): IServer;
+}>;
+export default Server;
+//# sourceMappingURL=Server.d.ts.map

package/src/boot/Server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../../src/boot/Server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAQjD,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAK9C,MAAM,WAAW,OAAO;IACtB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC;CAC9B;AA4ND;;;GAGG;AACH,eAAO,MAAM,MAAM;IACjB;;OAEG;gBACS,YAAY,SAAS,MAAM,SAAS,MAAM,GAAG,OAAO;EA8BhE,CAAC;AAEH,eAAe,MAAM,CAAC"}