@zintrust/core 0.4.15 → 0.4.17

package/src/cli/commands/runner/index.ts

@@ -0,0 +1,155 @@
+const quote = (value: string): string => JSON.stringify(value);
+const START_MODULE_PLACEHOLDER = '__ZINTRUST_START_MODULE__';
+
+const injectStartModuleSpecifier = (template: string, startModuleSpecifier: string): string => {
+  return template.replaceAll(START_MODULE_PLACEHOLDER, quote(startModuleSpecifier));
+};
+
+const denoRunnerTemplate = [
+  "import http from 'node:http';",
+  `import { deno } from ${START_MODULE_PLACEHOLDER};`,
+  '',
+  "const port = Number.parseInt(process.env.PORT ?? '3000', 10) || 3000;",
+  "const host = process.env.HOST ?? 'localhost';",
+  '',
+  'const readBody = async (req: http.IncomingMessage): Promise<Buffer | undefined> => {',
+  "  if (req.method === 'GET' || req.method === 'HEAD') return undefined;",
+  '  const chunks: Buffer[] = [];',
+  '  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));',
+  '  return chunks.length > 0 ? Buffer.concat(chunks) : undefined;',
+  '};',
+  '',
+  'const server = http.createServer(async (req, res) => {',
+  '  try {',
+  "    const proto = (req.headers['x-forwarded-proto'] ?? 'http').toString();",
+  '    const authority = (req.headers.host ?? host).toString();',
+  "    const url = new URL(req.url ?? '/', proto + '://' + authority);",
+  '',
+  '    const headers = new Headers();',
+  '    for (const [key, value] of Object.entries(req.headers)) {',
+  '      if (value === undefined) continue;',
+  '      if (Array.isArray(value)) {',
+  '        for (const v of value) headers.append(key, v);',
+  '      } else {',
+  '        headers.set(key, String(value));',
+  '      }',
+  '    }',
+  '',
+  '    const body = await readBody(req);',
+  '    const request = new Request(url.toString(), {',
+  "      method: req.method ?? 'GET',",
+  '      headers,',
+  '      body,',
+  '    });',
+  '',
+  '    const response = await deno(request);',
+  '',
+  '    res.statusCode = response.status;',
+  '    response.headers.forEach((v, k) => res.setHeader(k, v));',
+  '',
+  '    const ab = await response.arrayBuffer();',
+  '    res.end(Buffer.from(ab));',
+  '  } catch (err) {',
+  '    res.statusCode = 500;',
+  "    res.setHeader('content-type', 'text/plain');",
+  "    res.end('Internal Server Error' + (err as Error).message);",
+  '  }',
+  '});',
+  '',
+  'server.listen(port, host, () => {',
+  '  // eslint-disable-next-line no-console',
+  "  console.log('Deno adapter server listening at http://' + host + ':' + port);",
+  '});',
+  '',
+].join('\n');
+
+const lambdaRunnerTemplate = [
+  "import http from 'node:http';",
+  `import { handler as lambdaHandler } from ${START_MODULE_PLACEHOLDER};`,
+  '',
+  "const port = Number.parseInt(process.env.PORT ?? '3000', 10) || 3000;",
+  "const host = process.env.HOST ?? 'localhost';",
+  '',
+  'const readBody = async (req: http.IncomingMessage): Promise<string | undefined> => {',
+  "  if (req.method === 'GET' || req.method === 'HEAD') return undefined;",
+  '  const chunks: Buffer[] = [];',
+  '  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));',
+  "  return chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : undefined;",
+  '};',
+  '',
+  'const server = http.createServer(async (req, res) => {',
+  '  try {',
+  "    const proto = (req.headers['x-forwarded-proto'] ?? 'http').toString();",
+  '    const authority = (req.headers.host ?? host).toString();',
+  "    const url = new URL(req.url ?? '/', proto + '://' + authority);",
+  '',
+  '    const body = await readBody(req);',
+  '    const headers: Record<string, string> = {};',
+  '    for (const [k, v] of Object.entries(req.headers)) {',
+  '      if (v === undefined) continue;',
+  "      headers[k] = Array.isArray(v) ? v.join(',') : String(v);",
+  '    }',
+  '',
+  '    const queryStringParameters: Record<string, string> = {};',
+  '    url.searchParams.forEach((value, key) => {',
+  '      if (queryStringParameters[key] === undefined) queryStringParameters[key] = value;',
+  '    });',
+  '',
+  '    const event = {',
+  "      version: '2.0',",
+  "      routeKey: '$default',",
+  '      rawPath: url.pathname,',
+  '      rawQueryString: url.searchParams.toString(),',
+  '      headers,',
+  '      queryStringParameters,',
+  '      requestContext: {',
+  '        http: {',
+  "          method: req.method ?? 'GET',",
+  '          path: url.pathname,',
+  "          sourceIp: (req.socket.remoteAddress ?? '').toString(),",
+  '        },',
+  '      },',
+  '      body: body ?? null,',
+  '      isBase64Encoded: false,',
+  '    };',
+  '',
+  '    const result = (await lambdaHandler(event, {})) as {',
+  '      statusCode?: number;',
+  '      headers?: Record<string, string | string[]>;',
+  '      body?: string;',
+  '      isBase64Encoded?: boolean;',
+  '    };',
+  '',
+  '    res.statusCode = typeof result.statusCode === "number" ? result.statusCode : 200;',
+  '    if (result.headers) {',
+  '      for (const [k, v] of Object.entries(result.headers)) {',
+  '        res.setHeader(k, v as any);',
+  '      }',
+  '    }',
+  '',
+  '    if (result.isBase64Encoded === true && typeof result.body === "string") {',
+  "      res.end(Buffer.from(result.body, 'base64'));",
+  '    } else {',
+  "      res.end(result.body ?? '');",
+  '    }',
+  '  } catch {',
+  '    res.statusCode = 500;',
+  "    res.setHeader('content-type', 'application/json');",
+  "    res.end(JSON.stringify({ message: 'Internal Server Error' }));",
+  '  }',
+  '});',
+  '',
+  'server.listen(port, host, () => {',
+  '  // eslint-disable-next-line no-console',
+  "  console.log('Lambda adapter server listening at http://' + host + ':' + port);",
+  '});',
+  '',
+].join('\n');
+
+export const createDenoRunnerSource = (startModuleSpecifier: string): string => {
+  return injectStartModuleSpecifier(denoRunnerTemplate, startModuleSpecifier);
+};
+
+export const createLambdaRunnerSource = (startModuleSpecifier: string): string => {
+  return injectStartModuleSpecifier(lambdaRunnerTemplate, startModuleSpecifier);
+};

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

@@ -0,0 +1,69 @@
+import { databaseConfig } from '@config/database';
+import { registerDatabasesFromRuntimeConfig } from '@orm/DatabaseRuntimeRegistration';
+import { SchedulerRuntime } from '@scheduler/SchedulerRuntime';
+import type { ISchedule } from '@scheduler/types';
+
+type LoadedScheduleModules = {
+  core: ISchedule[];
+  app: ISchedule[];
+};
+
+const isSchedule = (value: unknown): value is ISchedule => {
+  if (value === undefined || value === null || typeof value !== 'object') return false;
+  return 'name' in value && typeof (value as { name?: unknown }).name === 'string';
+};
+
+const loadScheduleModules = async (): Promise<LoadedScheduleModules> => {
+  const coreSchedules = await import('@schedules/index');
+
+  let appSchedules: Record<string, unknown> = {};
+  try {
+    appSchedules = (await import('@app/Schedules')) as unknown as Record<string, unknown>;
+  } catch {
+    appSchedules = {};
+  }
+
+  return {
+    core: Object.values(coreSchedules).filter(isSchedule),
+    app: Object.values(appSchedules).filter(isSchedule),
+  };
+};
+
+const shutdownCliResources = async (): Promise<void> => {
+  try {
+    const mod = await import('@orm/ConnectionManager');
+    await mod.ConnectionManager.shutdownIfInitialized();
+  } catch {
+    // best-effort
+  }
+
+  try {
+    const mod = await import('@orm/Database');
+    await mod.resetDatabase();
+  } catch {
+    // best-effort
+  }
+
+  try {
+    const mod = (await import('@queue/LockProvider')) as unknown as {
+      closeLockProvider?: () => Promise<void>;
+    };
+    await mod.closeLockProvider?.();
+  } catch {
+    // best-effort
+  }
+};
+
+export const ScheduleCliSupport = Object.freeze({
+  async registerAll(): Promise<void> {
+    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.ts

@@ -0,0 +1,228 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+
+import type { ProjectConfig } from '@cli/config/ConfigSchema';
+import {
+  ConfigPaths,
+  DEFAULT_CONFIG,
+  getConfigValue,
+  setConfigValue,
+} from '@cli/config/ConfigSchema';
+import { Logger } from '@config/logger';
+import { ErrorFactory } from '@exceptions/ZintrustError';
+import * as path from '@node-singletons/path';
+
+const loadFsPromises = async (): Promise<typeof import('@node-singletons/fs').fsPromises> => {
+  const mod = await import('@node-singletons/fs');
+  return mod.fsPromises;
+};
+
+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[];
+}
+
+interface ConfigState {
+  config: ProjectConfig | null;
+  configPath: string;
+}
+
+/**
+ * Deep merge helper
+ */
+const deepMerge = (
+  target: Record<string, unknown>,
+  source: Record<string, unknown>
+): Record<string, unknown> => {
+  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] as Record<string, unknown>) ?? {},
+        source[key] as Record<string, unknown>
+      );
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Load configuration from file
+ */
+async function loadConfig(state: ConfigState): Promise<ProjectConfig> {
+  try {
+    const fs = await loadFsPromises();
+    const content = await fs.readFile(state.configPath, 'utf-8');
+    state.config = JSON.parse(content) as ProjectConfig;
+    return state.config;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).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 as Error).message}`);
+    throw err;
+  }
+}
+
+/**
+ * Save configuration to file
+ */
+async function saveConfig(state: ConfigState, newConfig?: ProjectConfig): Promise<void> {
+  const toSave = newConfig ?? state.config;
+  if (!toSave) {
+    throw ErrorFactory.createConfigError('No configuration to save');
+  }
+
+  try {
+    const fs = await loadFsPromises();
+    // 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 as Error).message}`);
+    throw err;
+  }
+}
+
+/**
+ * Get current configuration
+ */
+function getConfig(state: ConfigState): ProjectConfig {
+  state.config ??= structuredClone(DEFAULT_CONFIG);
+  return state.config;
+}
+
+/**
+ * Check if config file exists
+ */
+async function configExists(configPath: string): Promise<boolean> {
+  try {
+    const fs = await loadFsPromises();
+    await fs.access(configPath);
+    return true;
+  } catch (error) {
+    ErrorFactory.createCliError('Config file access check failed', error);
+    return false;
+  }
+}
+
+/**
+ * Flatten object keys
+ */
+function flattenKeys(obj: Record<string, unknown>, prefix = ''): string[] {
+  const keys: string[] = [];
+  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 as Record<string, unknown>, 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: string = ConfigPaths.PROJECT_CONFIG): IConfigManager {
+    const state: ConfigState = {
+      config: null,
+      configPath,
+    };
+
+    return {
+      load: async () => loadConfig(state),
+      save: async (newConfig?: ProjectConfig) => saveConfig(state, newConfig),
+      getConfig: () => getConfig(state),
+      get(key: string): unknown {
+        return getConfigValue(getConfig(state) as Record<string, unknown>, key);
+      },
+      set(key: string, value: unknown): void {
+        setConfigValue(getConfig(state) as Record<string, unknown>, key, value);
+      },
+      exists: async () => configExists(configPath),
+      async create(initialConfig?: Partial<ProjectConfig>): Promise<void> {
+        const newConfig = { ...DEFAULT_CONFIG, ...initialConfig };
+        await saveConfig(state, newConfig as ProjectConfig);
+      },
+      async reset(): Promise<void> {
+        state.config = structuredClone(DEFAULT_CONFIG);
+        await saveConfig(state);
+      },
+      merge(partial: Partial<ProjectConfig>): void {
+        const currentConfig = getConfig(state);
+        state.config = deepMerge(
+          currentConfig as Record<string, unknown>,
+          partial as Record<string, unknown>
+        ) as ProjectConfig;
+      },
+      export: () => JSON.stringify(getConfig(state), null, 2),
+      getAllKeys: () => flattenKeys(getConfig(state) as Record<string, unknown>),
+    };
+  },
+
+  /**
+   * Create global config directory if not exists
+   */
+  async ensureGlobalConfigDir(): Promise<void> {
+    try {
+      const fs = await loadFsPromises();
+      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 as Error).message}`);
+    }
+  },
+
+  /**
+   * Get or create global config manager
+   */
+  async getGlobalConfig(): Promise<IConfigManager> {
+    await this.ensureGlobalConfigDir();
+    const manager = this.create(ConfigPaths.GLOBAL_CONFIG);
+    await manager.load();
+    return manager;
+  },
+
+  /**
+   * Get or create project config manager
+   */
+  async getProjectConfig(): Promise<IConfigManager> {
+    const manager = this.create(ConfigPaths.PROJECT_CONFIG);
+    await manager.load();
+    return manager;
+  },
+});