@zintrust/core 3.5.1 → 3.6.0

package/src/cli/commands/schedule/ScheduleCliSupport.js

@@ -0,0 +1,206 @@
+import { SpawnUtil } from '../../utils/spawn.js';
+import { databaseConfig } from '../../../config/database.js';
+import { ErrorFactory } from '../../../exceptions/ZintrustError.js';
+import { existsSync } from '../../../node-singletons/fs.js';
+import path from '../../../node-singletons/path.js';
+import { registerDatabasesFromRuntimeConfig } from '../../../orm/DatabaseRuntimeRegistration.js';
+import { ensureNodeStartupEnvLoaded } from '../../../runtime/NodeStartup.js';
+import { resolveNodeProjectRoot } from '../../../runtime/resolveNodeProjectRoot.js';
+import useFileLoader from '../../../runtime/useFileLoader.js';
+import { SchedulerRuntime } from '../../../scheduler/SchedulerRuntime.js';
+const SOURCE_REENTRY_ENV = 'ZINTRUST_SCHEDULE_CLI_SOURCE_REENTRY';
+const isSchedule = (value) => {
+    if (value === undefined || value === null || typeof value !== 'object')
+        return false;
+    return 'name' in value && typeof value.name === 'string';
+};
+const getDefaultExport = (moduleNamespace) => {
+    return Object.hasOwn(moduleNamespace, 'default') ? moduleNamespace['default'] : undefined;
+};
+const flattenScheduleCandidates = (moduleNamespace) => {
+    const candidates = [
+        ...Object.values(moduleNamespace),
+        getDefaultExport(moduleNamespace),
+    ];
+    return candidates.flatMap((value) => (Array.isArray(value) ? value : [value]));
+};
+const collectSchedules = (moduleNamespace) => {
+    const flattenedCandidates = flattenScheduleCandidates(moduleNamespace);
+    const seen = new Set();
+    return flattenedCandidates.filter(isSchedule).filter((schedule) => {
+        const normalizedName = schedule.name.trim();
+        if (normalizedName === '' || seen.has(normalizedName)) {
+            return false;
+        }
+        seen.add(normalizedName);
+        return true;
+    });
+};
+const getProjectScheduleLoaders = () => [
+    useFileLoader('app/Schedules/index.ts'),
+    useFileLoader('app/Schedules.ts'),
+];
+const isTypeScriptFile = (filePath) => {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.ts' || ext === '.tsx' || ext === '.mts';
+};
+const getProjectSourceCliEntry = (projectRoot) => {
+    const candidates = [
+        path.join(projectRoot, 'bin', 'zin.ts'),
+        path.join(projectRoot, 'bin', 'zintrust.ts'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+};
+const getCurrentCliScript = () => {
+    const script = String(process.argv[1] ?? '').trim();
+    if (script.length === 0)
+        return undefined;
+    const resolvedScript = path.resolve(script);
+    return existsSync(resolvedScript) ? resolvedScript : undefined;
+};
+const isRunningProjectSourceCli = (projectRoot) => {
+    const resolvedScript = getCurrentCliScript();
+    if (resolvedScript === undefined)
+        return false;
+    const sourceCliEntry = getProjectSourceCliEntry(projectRoot);
+    if (sourceCliEntry === undefined)
+        return false;
+    return resolvedScript === path.resolve(sourceCliEntry);
+};
+const getScheduleReentryScript = (projectRoot) => {
+    const sourceCliEntry = getProjectSourceCliEntry(projectRoot);
+    if (sourceCliEntry !== undefined) {
+        return path.relative(projectRoot, sourceCliEntry);
+    }
+    const currentCliScript = getCurrentCliScript();
+    if (currentCliScript === undefined)
+        return undefined;
+    const relativeCurrentScript = path.relative(projectRoot, currentCliScript);
+    return relativeCurrentScript.startsWith('..') ? currentCliScript : relativeCurrentScript;
+};
+const getExistingProjectSchedulePath = () => {
+    for (const loader of getProjectScheduleLoaders()) {
+        if (loader.exists())
+            return loader.path();
+    }
+    return undefined;
+};
+const tryLoadProjectScheduleModuleFromFiles = async () => {
+    const existingLoaders = getProjectScheduleLoaders()
+        .filter((loader) => loader.exists())
+        .map((loader) => ({ loader, loadedPath: loader.path() }));
+    const tryAt = async (index, firstError) => {
+        const entry = existingLoaders[index];
+        if (entry === undefined) {
+            if (existingLoaders.length > 0 && firstError !== undefined)
+                throw firstError;
+            return undefined;
+        }
+        try {
+            return {
+                module: await entry.loader.getModule(),
+                loadedPath: entry.loadedPath,
+            };
+        }
+        catch (error) {
+            return tryAt(index + 1, firstError ?? error);
+        }
+    };
+    return tryAt(0);
+};
+const loadAppScheduleModule = async () => {
+    const fileLoaded = await tryLoadProjectScheduleModuleFromFiles();
+    if (fileLoaded !== undefined) {
+        return fileLoaded;
+    }
+    try {
+        return {
+            module: (await import('../../../../app/Schedules/index.js')),
+        };
+    }
+    catch {
+        return fileLoaded ?? { module: {} };
+    }
+};
+const loadScheduleModules = async () => {
+    const coreSchedules = await import('../../../schedules/index.js');
+    const appSchedules = await loadAppScheduleModule();
+    return {
+        core: collectSchedules(coreSchedules),
+        app: collectSchedules(appSchedules.module),
+    };
+};
+const ensureProjectSourceContext = async () => {
+    await ensureNodeStartupEnvLoaded({ entry: 'schedule-cli' });
+    const projectRoot = await resolveNodeProjectRoot();
+    if ((process.env['ZINTRUST_PROJECT_ROOT'] ?? '').trim() === '') {
+        process.env['ZINTRUST_PROJECT_ROOT'] = projectRoot;
+    }
+    const existingSchedulePath = getExistingProjectSchedulePath();
+    if (existingSchedulePath === undefined || !isTypeScriptFile(existingSchedulePath)) {
+        return false;
+    }
+    if (String(process.env[SOURCE_REENTRY_ENV] ?? '') === '1') {
+        return false;
+    }
+    if (isRunningProjectSourceCli(projectRoot)) {
+        return false;
+    }
+    const reentryScript = getScheduleReentryScript(projectRoot);
+    if (reentryScript === undefined) {
+        throw ErrorFactory.createCliError('Source schedules require either a project CLI entrypoint at bin/zin.ts or bin/zintrust.ts, or a resolvable current CLI script.');
+    }
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: 'tsx',
+        args: [reentryScript, ...process.argv.slice(2)],
+        cwd: projectRoot,
+        env: {
+            ...process.env,
+            ZINTRUST_PROJECT_ROOT: projectRoot,
+            [SOURCE_REENTRY_ENV]: '1',
+        },
+    });
+    if (exitCode !== 0) {
+        throw ErrorFactory.createCliError(`Failed to execute schedule command via project source CLI (exit ${exitCode})`);
+    }
+    return true;
+};
+const shutdownCliResources = async () => {
+    try {
+        const mod = await import('../../../orm/ConnectionManager.js');
+        await mod.ConnectionManager.shutdownIfInitialized();
+    }
+    catch {
+        // best-effort
+    }
+    try {
+        const mod = await import('../../../orm/Database.js');
+        await mod.resetDatabase();
+    }
+    catch {
+        // best-effort
+    }
+    try {
+        const mod = (await import('../../../tools/queue/LockProvider.js'));
+        await mod.closeLockProvider?.();
+    }
+    catch {
+        // best-effort
+    }
+};
+export const ScheduleCliSupport = Object.freeze({
+    ensureProjectSourceContext,
+    async registerAll() {
+        await ensureNodeStartupEnvLoaded({ entry: 'schedule-cli' });
+        registerDatabasesFromRuntimeConfig(databaseConfig);
+        const modules = await loadScheduleModules();
+        SchedulerRuntime.registerMany(modules.core, 'core');
+        SchedulerRuntime.registerMany(modules.app, 'app');
+    },
+    shutdownCliResources,
+});
+export default ScheduleCliSupport;

package/src/cli/config/ConfigManager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import type { ProjectConfig } from './ConfigSchema.js';
+export interface IConfigManager {
+    load(): Promise<ProjectConfig>;
+    save(config?: ProjectConfig): Promise<void>;
+    getConfig(): ProjectConfig;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    exists(): Promise<boolean>;
+    create(initialConfig?: Partial<ProjectConfig>): Promise<void>;
+    reset(): Promise<void>;
+    merge(partial: Partial<ProjectConfig>): void;
+    export(): string;
+    getAllKeys(): string[];
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export declare const ConfigManager: Readonly<{
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath?: string): IConfigManager;
+    /**
+     * Create global config directory if not exists
+     */
+    ensureGlobalConfigDir(): Promise<void>;
+    /**
+     * Get or create global config manager
+     */
+    getGlobalConfig(): Promise<IConfigManager>;
+    /**
+     * Get or create project config manager
+     */
+    getProjectConfig(): Promise<IConfigManager>;
+}>;
+//# sourceMappingURL=ConfigManager.d.ts.map

package/src/cli/config/ConfigManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigManager.d.ts","sourceRoot":"","sources":["../../../../src/cli/config/ConfigManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAY9D,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/B,IAAI,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,IAAI,aAAa,CAAC;IAC3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,MAAM,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC7C,MAAM,IAAI,MAAM,CAAC;IACjB,UAAU,IAAI,MAAM,EAAE,CAAC;CACxB;AAkHD;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;wBACgB,MAAM,GAAgC,cAAc;IAqCvE;;OAEG;6BAC4B,OAAO,CAAC,IAAI,CAAC;IAS5C;;OAEG;uBACsB,OAAO,CAAC,cAAc,CAAC;IAOhD;;OAEG;wBACuB,OAAO,CAAC,cAAc,CAAC;EAKjD,CAAC"}

package/src/cli/config/ConfigManager.js

@@ -0,0 +1,175 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import { ConfigPaths, DEFAULT_CONFIG, getConfigValue, setConfigValue, } from './ConfigSchema.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { fsPromises as fs } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+/**
+ * Deep merge helper
+ */
+const deepMerge = (target, source) => {
+    const result = { ...target };
+    for (const key in source) {
+        if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] ?? {}, source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+};
+/**
+ * Load configuration from file
+ */
+async function loadConfig(state) {
+    try {
+        const content = await fs.readFile(state.configPath, 'utf-8');
+        state.config = JSON.parse(content);
+        return state.config;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            Logger.debug(`Config file not found at ${state.configPath}, using defaults`);
+            state.config = structuredClone(DEFAULT_CONFIG);
+            return state.config;
+        }
+        ErrorFactory.createCliError(`Failed to load config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Save configuration to file
+ */
+async function saveConfig(state, newConfig) {
+    const toSave = newConfig ?? state.config;
+    if (!toSave) {
+        throw ErrorFactory.createConfigError('No configuration to save');
+    }
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(state.configPath);
+        if (dir !== '.') {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        // Write config with nice formatting
+        await fs.writeFile(state.configPath, JSON.stringify(toSave, null, 2));
+        state.config = toSave;
+        Logger.debug(`Config saved to ${state.configPath}`);
+    }
+    catch (err) {
+        ErrorFactory.createCliError(`Failed to save config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Get current configuration
+ */
+function getConfig(state) {
+    state.config ??= structuredClone(DEFAULT_CONFIG);
+    return state.config;
+}
+/**
+ * Check if config file exists
+ */
+async function configExists(configPath) {
+    try {
+        await fs.access(configPath);
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Config file access check failed', error);
+        return false;
+    }
+}
+/**
+ * Flatten object keys
+ */
+function flattenKeys(obj, prefix = '') {
+    const keys = [];
+    for (const key in obj) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        const value = obj[key];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            keys.push(...flattenKeys(value, fullKey));
+        }
+        else {
+            keys.push(fullKey);
+        }
+    }
+    return keys;
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export const ConfigManager = Object.freeze({
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath = ConfigPaths.PROJECT_CONFIG) {
+        const state = {
+            config: null,
+            configPath,
+        };
+        return {
+            load: async () => loadConfig(state),
+            save: async (newConfig) => saveConfig(state, newConfig),
+            getConfig: () => getConfig(state),
+            get(key) {
+                return getConfigValue(getConfig(state), key);
+            },
+            set(key, value) {
+                setConfigValue(getConfig(state), key, value);
+            },
+            exists: async () => configExists(configPath),
+            async create(initialConfig) {
+                const newConfig = { ...DEFAULT_CONFIG, ...initialConfig };
+                await saveConfig(state, newConfig);
+            },
+            async reset() {
+                state.config = structuredClone(DEFAULT_CONFIG);
+                await saveConfig(state);
+            },
+            merge(partial) {
+                const currentConfig = getConfig(state);
+                state.config = deepMerge(currentConfig, partial);
+            },
+            export: () => JSON.stringify(getConfig(state), null, 2),
+            getAllKeys: () => flattenKeys(getConfig(state)),
+        };
+    },
+    /**
+     * Create global config directory if not exists
+     */
+    async ensureGlobalConfigDir() {
+        try {
+            await fs.mkdir(ConfigPaths.GLOBAL_DIR, { recursive: true });
+        }
+        catch (err) {
+            ErrorFactory.createCliError('Could not create global config dir', err);
+            Logger.debug(`Could not create global config dir: ${err.message}`);
+        }
+    },
+    /**
+     * Get or create global config manager
+     */
+    async getGlobalConfig() {
+        await this.ensureGlobalConfigDir();
+        const manager = this.create(ConfigPaths.GLOBAL_CONFIG);
+        await manager.load();
+        return manager;
+    },
+    /**
+     * Get or create project config manager
+     */
+    async getProjectConfig() {
+        const manager = this.create(ConfigPaths.PROJECT_CONFIG);
+        await manager.load();
+        return manager;
+    },
+});

package/src/cli/config/ConfigSchema.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Configuration Schema
+ * Defines the structure and types for ZinTrust configuration
+ */
+export interface DatabaseConfig {
+    connection: 'sqlite' | 'postgres' | 'mysql' | 'mariadb';
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    charset?: string;
+    collation?: string;
+    synchronize?: boolean;
+    logging?: boolean;
+}
+export interface ServerConfig {
+    port: number;
+    host: string;
+    environment: 'development' | 'production' | 'testing';
+    debug: boolean;
+    profiling: boolean;
+    tracing: boolean;
+}
+export interface AuthConfig {
+    enabled: boolean;
+    strategy: 'jwt' | 'session' | 'apikey';
+    jwtSecret?: string;
+    sessionSecret?: string;
+    expiresIn: string;
+}
+export interface MicroservicesConfig {
+    enabled: boolean;
+    port: number;
+    apiGatewayPort?: number;
+    discoveryType: 'filesystem' | 'consul' | 'kubernetes';
+    healthCheckInterval: number;
+}
+export interface FeatureConfig {
+    auth: boolean;
+    database: boolean;
+    cache: boolean;
+    queue: boolean;
+    storage: boolean;
+    email: boolean;
+    webhooks: boolean;
+    monitoring: boolean;
+}
+export interface ProjectConfig {
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    database: DatabaseConfig;
+    server: ServerConfig;
+    auth: AuthConfig;
+    microservices: MicroservicesConfig;
+    features: FeatureConfig;
+    [key: string]: unknown;
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: Readonly<{
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    database: {
+        connection: "sqlite";
+        charset: string;
+        collation: string;
+        synchronize: true;
+        logging: false;
+    };
+    server: {
+        port: number;
+        host: string;
+        environment: "development";
+        debug: false;
+        profiling: false;
+        tracing: false;
+    };
+    auth: {
+        enabled: false;
+        strategy: "jwt";
+        expiresIn: string;
+    };
+    microservices: {
+        enabled: false;
+        port: number;
+        discoveryType: "filesystem";
+        healthCheckInterval: number;
+    };
+    features: {
+        auth: false;
+        database: true;
+        cache: false;
+        queue: false;
+        storage: false;
+        email: false;
+        webhooks: false;
+        monitoring: false;
+    };
+}>;
+/**
+ * Configuration paths
+ * Sealed namespace for immutability
+ */
+export declare const ConfigPaths: Readonly<{
+    GLOBAL_DIR: string;
+    GLOBAL_CONFIG: `${string}/config.json`;
+    PROJECT_CONFIG: ".zintrust.json";
+    PROJECT_CONFIG_TS: "zintrust.config.ts";
+    ENV_FILE: ".env";
+    ENV_EXAMPLE: ".env.example";
+}>;
+/**
+ * Validation rule interface
+ */
+export interface ValidationRule {
+    type?: string;
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    min?: number;
+    max?: number;
+    enum?: string[];
+    description?: string;
+}
+/**
+ * Validation rules for each config section
+ * Sealed namespace for immutability
+ */
+export declare const CONFIG_RULES: Readonly<{
+    name: {
+        type: string;
+        required: boolean;
+        minLength: number;
+        maxLength: number;
+        pattern: RegExp;
+        description: string;
+    };
+    version: {
+        type: string;
+        required: boolean;
+        pattern: RegExp;
+        description: string;
+    };
+    'server.port': {
+        type: string;
+        required: boolean;
+        min: number;
+        max: number;
+        description: string;
+    };
+    'server.environment': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+    'database.connection': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+    'auth.strategy': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+    'microservices.discoveryType': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+}>;
+/**
+ * Get default config for a specific key
+ */
+export declare function getDefaultValue(key: string): unknown;
+/**
+ * Set config value in object (deep set)
+ */
+export declare function setConfigValue(obj: Record<string, unknown>, path: string, value: unknown): void;
+/**
+ * Get config value from object (deep get)
+ */
+export declare function getConfigValue(obj: Record<string, unknown>, path: string): unknown;
+//# sourceMappingURL=ConfigSchema.d.ts.map

package/src/cli/config/ConfigSchema.d.ts.map

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