@zintrust/core 0.1.26 → 0.1.28

package/src/cli/commands/WorkerCommands.ts

@@ -0,0 +1,373 @@
+/* eslint-disable no-console */
+/**
+ * Worker Management CLI Commands
+ * Command-line interface for managing workers
+ */
+
+import { ErrorFactory } from '@/exceptions/ZintrustError';
+import type { IBaseCommand } from '@cli/BaseCommand';
+import { BaseCommand } from '@cli/BaseCommand';
+import { Logger } from '@config/logger';
+type WorkersModule = typeof import('@zintrust/workers');
+
+type WorkerRegistryStatus = {
+  status?: string;
+  version?: string;
+  queueName?: string;
+  concurrency?: number;
+  region?: string;
+  startedAt?: Date | string;
+};
+
+type WorkerFactoryApi = {
+  list: () => string[];
+  listPersisted: () => Promise<string[]>;
+  getHealth: (name: string) => Promise<unknown>;
+  getMetrics: (name: string) => Promise<unknown>;
+  stop: (name: string) => Promise<void>;
+  restart: (name: string) => Promise<void>;
+  start: (name: string) => Promise<void>;
+};
+
+type WorkerRegistryApi = {
+  status: (name: string) => WorkerRegistryStatus | null;
+  start: (name: string) => Promise<void>;
+};
+
+type HealthMonitorApi = {
+  getSummary: () => Array<{ status: 'healthy' | 'degraded' | 'unhealthy' | 'critical' }>;
+};
+
+type ResourceMonitorApi = {
+  getCurrentUsage: (workerName: string) => {
+    cpu: number;
+    memory: { percent: number; used: number };
+    cost: { hourly: number; daily: number };
+  };
+};
+
+// Lazy initialization to prevent temporal dead zone issues
+let WorkerFactory: WorkerFactoryApi | undefined;
+let WorkerRegistry: WorkerRegistryApi | undefined;
+let HealthMonitor: HealthMonitorApi | undefined;
+let ResourceMonitor: ResourceMonitorApi | undefined;
+let workersModulePromise: Promise<WorkersModule> | undefined;
+
+const loadWorkersModule = async (): Promise<WorkersModule> => {
+  workersModulePromise ??= import('@zintrust/workers');
+
+  try {
+    return await workersModulePromise;
+  } catch (error) {
+    Logger.error(
+      'Failed to load optional package "@zintrust/workers"; worker commands require this package.',
+      error
+    );
+    throw ErrorFactory.createCliError(
+      'Optional package "@zintrust/workers" is required for worker commands. Install it to use worker:* commands.'
+    );
+  }
+};
+
+const getWorkerFactory = async (): Promise<WorkerFactoryApi> => {
+  if (!WorkerFactory) {
+    const mod = await loadWorkersModule();
+    WorkerFactory = mod.WorkerFactory as unknown as WorkerFactoryApi;
+  }
+  return WorkerFactory;
+};
+
+const getWorkerRegistry = async (): Promise<WorkerRegistryApi> => {
+  if (!WorkerRegistry) {
+    const mod = await loadWorkersModule();
+    WorkerRegistry = mod.WorkerRegistry as unknown as WorkerRegistryApi;
+  }
+  return WorkerRegistry;
+};
+
+const getHealthMonitor = async (): Promise<HealthMonitorApi> => {
+  if (!HealthMonitor) {
+    const mod = await loadWorkersModule();
+    HealthMonitor = mod.HealthMonitor as unknown as HealthMonitorApi;
+  }
+  return HealthMonitor;
+};
+
+const getResourceMonitor = async (): Promise<ResourceMonitorApi> => {
+  if (!ResourceMonitor) {
+    const mod = await loadWorkersModule();
+    ResourceMonitor = mod.ResourceMonitor as unknown as ResourceMonitorApi;
+  }
+  return ResourceMonitor;
+};
+
+/**
+ * Helper: Format table output
+ */
+const formatTable = (headers: string[], rows: string[][]): string => {
+  const columnWidths = headers.map((h, i) => {
+    const maxRowWidth = Math.max(...rows.map((r) => (r[i] || '').length));
+    return Math.max(h.length, maxRowWidth);
+  });
+
+  const headerRow = headers.map((h, i) => h.padEnd(columnWidths[i])).join(' | ');
+  const separator = columnWidths.map((w) => '-'.repeat(w)).join('-+-');
+  const dataRows = rows.map((row) =>
+    row.map((cell, i) => (cell || '').padEnd(columnWidths[i])).join(' | ')
+  );
+
+  return [headerRow, separator, ...dataRows].join('\n');
+};
+
+/**
+ * Worker List Command
+ */
+const createWorkerListCommand = (): IBaseCommand => {
+  const ext = async (): Promise<void> => {
+    try {
+      const workers = await (await getWorkerFactory()).listPersisted();
+
+      console.log(`\nTotal Workers: ${workers.length}\n`);
+
+      if (workers.length === 0) {
+        console.log('No workers found.');
+        return;
+      }
+
+      const registry = await getWorkerRegistry();
+      const rows = workers.map((name: string) => {
+        const status = registry.status(name);
+        return [
+          name,
+          status?.status ?? 'unknown',
+          status?.version ?? 'N/A',
+          status?.queueName ?? 'N/A',
+          String(status?.concurrency ?? 0),
+        ];
+      });
+
+      console.log(formatTable(['Name', 'Status', 'Version', 'Queue', 'Concurrency'], rows));
+      console.log();
+    } catch (error) {
+      Logger.error('worker:list command failed', error);
+      process.exit(1);
+    }
+  };
+
+  const cmd = BaseCommand.create({
+    name: 'worker:list',
+    description: 'List all workers',
+    execute: async () => ext(),
+  });
+
+  return cmd;
+};
+
+/**
+ * Worker Status Command
+ */
+const createWorkerStatusCommand = (): IBaseCommand => {
+  const ext = async (name: string): Promise<void> => {
+    try {
+      if (!name) {
+        Logger.error('Error: Worker name is required');
+        process.exit(1);
+      }
+
+      const status = (await getWorkerRegistry()).status(name);
+      const health = await (await getWorkerFactory()).getHealth(name);
+      const healthData =
+        typeof health === 'object' && health !== null
+          ? (health as { score?: number; status?: string })
+          : {};
+      const metrics = await (await getWorkerFactory()).getMetrics(name);
+
+      console.log(`\n=== Worker: ${name} ===\n`);
+      console.log(`Status: ${status?.status}`);
+      console.log(`Version: ${status?.version}`);
+      console.log(`Queue: ${status?.queueName}`);
+      console.log(`Region: ${status?.region ?? 'N/A'}`);
+      console.log(`Started: ${status?.startedAt}`);
+      console.log(`Concurrency: ${status?.concurrency}`);
+      console.log(`\nHealth Score: ${healthData.score ?? 'N/A'}`);
+      console.log(`Health Status: ${healthData.status ?? 'N/A'}`);
+      console.log(`\nMetrics:`);
+      console.log(JSON.stringify(metrics, null, 2));
+      console.log();
+    } catch (error) {
+      Logger.error('worker:status command failed', error);
+      process.exit(1);
+    }
+  };
+
+  const cmd = BaseCommand.create({
+    name: 'worker:status',
+    description: 'Get detailed status of a worker',
+    addOptions: (command) => {
+      command.argument('<name>', 'Worker name');
+    },
+    execute: async (options) => ext((options.args?.[0] as string) ?? ''),
+  });
+
+  return cmd;
+};
+
+/**
+ * Worker Start Command
+ */
+const createWorkerStartCommand = (): IBaseCommand => {
+  const ext = async (name: string): Promise<void> => {
+    try {
+      if (!name) {
+        Logger.error('Error: Worker name is required');
+        process.exit(1);
+      }
+
+      await (await getWorkerFactory()).start(name);
+      Logger.info(`✓ Worker "${name}" started successfully`);
+    } catch (error) {
+      Logger.error('worker:start command failed', error);
+      process.exit(1);
+    }
+  };
+
+  const cmd = BaseCommand.create({
+    name: 'worker:start',
+    description: 'Start a worker',
+    addOptions: (command) => {
+      command.argument('<name>', 'Worker name');
+    },
+    execute: async (options) => ext((options.args?.[0] as string) ?? ''),
+  });
+
+  return cmd;
+};
+
+/**
+ * Worker Stop Command
+ */
+const createWorkerStopCommand = (): IBaseCommand => {
+  const ext = async (name: string): Promise<void> => {
+    try {
+      if (!name) {
+        console.error('Error: Worker name is required');
+        process.exit(1);
+      }
+
+      await (await getWorkerFactory()).stop(name);
+      console.log(`✓ Worker "${name}" stopped successfully`);
+    } catch (error) {
+      Logger.error('worker:stop command failed', error);
+      console.error(`Error: ${(error as Error).message}`);
+      process.exit(1);
+    }
+  };
+
+  const cmd = BaseCommand.create({
+    name: 'worker:stop',
+    description: 'Stop a worker',
+    addOptions: (command) => {
+      command.argument('<name>', 'Worker name');
+    },
+    execute: async (options) => ext((options.args?.[0] as string) ?? ''),
+  });
+
+  return cmd;
+};
+
+/**
+ * Worker Restart Command
+ */
+const createWorkerRestartCommand = (): IBaseCommand => {
+  const ext = async (name: string): Promise<void> => {
+    try {
+      if (!name) {
+        console.error('Error: Worker name is required');
+        process.exit(1);
+      }
+
+      await (await getWorkerFactory()).restart(name);
+      console.log(`✓ Worker "${name}" restarted successfully`);
+    } catch (error) {
+      Logger.error('worker:restart command failed', error);
+      console.error(`Error: ${(error as Error).message}`);
+      process.exit(1);
+    }
+  };
+
+  const cmd = BaseCommand.create({
+    name: 'worker:restart',
+    description: 'Restart a worker',
+    addOptions: (command) => {
+      command.argument('<name>', 'Worker name');
+    },
+    execute: async (options) => ext((options.args?.[0] as string) ?? ''),
+  });
+
+  return cmd;
+};
+
+/**
+ * Worker Summary Command
+ */
+const createWorkerSummaryCommand = (): IBaseCommand => {
+  const ext = async (): Promise<void> => {
+    try {
+      const workers = (await getWorkerFactory()).list();
+      const monitoringSummary = (await getHealthMonitor()).getSummary();
+      const resourceUsage = (await getResourceMonitor()).getCurrentUsage('system');
+
+      console.log(`\n=== Worker System Summary ===\n`);
+      console.log(`Total Workers: ${workers.length}`);
+      console.log(`\nHealth Overview:`);
+
+      const healthCounts = {
+        healthy: 0,
+        degraded: 0,
+        unhealthy: 0,
+        critical: 0,
+      };
+
+      monitoringSummary.forEach((w) => {
+        healthCounts[w.status]++;
+      });
+
+      console.log(`  Healthy: ${healthCounts.healthy}`);
+      console.log(`  Degraded: ${healthCounts.degraded}`);
+      console.log(`  Unhealthy: ${healthCounts.unhealthy}`);
+      console.log(`  Critical: ${healthCounts.critical}`);
+
+      console.log(`\nSystem Resources:`);
+      console.log(`  CPU: ${resourceUsage.cpu.toFixed(1)}%`);
+      console.log(
+        `  Memory: ${resourceUsage.memory.percent.toFixed(1)}% (${(resourceUsage.memory.used / 1024 / 1024 / 1024).toFixed(2)} GB used)`
+      );
+      console.log(`  Cost (hourly): $${resourceUsage.cost.hourly.toFixed(2)}`);
+      console.log(`  Cost (daily): $${resourceUsage.cost.daily.toFixed(2)}`);
+      console.log();
+    } catch (error) {
+      Logger.error('worker:summary command failed', error);
+      process.exit(1);
+    }
+  };
+
+  const cmd = BaseCommand.create({
+    name: 'worker:summary',
+    description: 'Get system-wide worker summary',
+    execute: async () => ext(),
+  });
+
+  return cmd;
+};
+
+/**
+ * Export worker command creators
+ */
+export const WorkerCommands = {
+  createWorkerListCommand,
+  createWorkerStatusCommand,
+  createWorkerStartCommand,
+  createWorkerStopCommand,
+  createWorkerRestartCommand,
+  createWorkerSummaryCommand,
+};

package/src/cli/commands/createKindWorkCommand.ts

@@ -0,0 +1,56 @@
+import { BaseCommand, type CommandOptions, type IBaseCommand } from '@cli/BaseCommand';
+import { QueueWorkCommandUtils } from '@cli/commands/QueueWorkCommandUtils';
+import { QueueWorkRunner, type QueueWorkKind } from '@cli/workers/QueueWorkRunner';
+import type { Command } from 'commander';
+
+type KindWorkCommandOptions = CommandOptions & {
+  timeout?: string;
+  retry?: string;
+  maxItems?: string;
+  driver?: string;
+};
+
+export function createKindWorkCommand(options: {
+  name: string;
+  description: string;
+  kind: QueueWorkKind;
+  helpHint: string;
+}): IBaseCommand {
+  return BaseCommand.create({
+    name: options.name,
+    description: options.description,
+    addOptions: (command: Command) => {
+      command
+        .argument('<queueName>', 'Queue name to work')
+        .option('--timeout <seconds>', 'Stop after this many seconds (default: 10)')
+        .option('--retry <count>', 'Retries after first attempt (default: 3)')
+        .option('--max-items <count>', 'Max items to process in one run (default: 1000)')
+        .option('--driver <name>', 'Queue driver name (default: from QUEUE_DRIVER)');
+    },
+    execute: async (cmdOptions: KindWorkCommandOptions) => {
+      const queueName = QueueWorkCommandUtils.requireQueueNameFromArgs(
+        cmdOptions.args,
+        options.helpHint
+      );
+
+      const timeoutSeconds = QueueWorkCommandUtils.parsePositiveInt(
+        cmdOptions.timeout,
+        '--timeout'
+      );
+      const retry = QueueWorkCommandUtils.parseNonNegativeInt(cmdOptions.retry, '--retry');
+      const maxItems = QueueWorkCommandUtils.parsePositiveInt(cmdOptions.maxItems, '--max-items');
+      const driverName = QueueWorkCommandUtils.normalizeDriverName(cmdOptions.driver);
+
+      const result = await QueueWorkRunner.run({
+        kind: options.kind,
+        queueName,
+        timeoutSeconds,
+        retry,
+        maxItems,
+        driverName,
+      });
+
+      QueueWorkCommandUtils.logSummary(queueName, options.kind, result);
+    },
+  });
+}

package/src/cli/commands/index.ts

@@ -0,0 +1,28 @@
+/**
+ * CLI Commands Module Index
+ */
+
+export { AddCommand } from '@cli/commands/AddCommand';
+export { BroadcastWorkCommand } from '@cli/commands/BroadcastWorkCommand';
+export { ConfigCommand } from '@cli/commands/ConfigCommand';
+export {
+  AddMigrationCommand,
+  CreateCommand,
+  CreateMigrationCommand,
+} from '@cli/commands/CreateCommand';
+export { DebugCommand } from '@cli/commands/DebugCommand';
+export { JwtDevCommand } from '@cli/commands/JwtDevCommand';
+export { LogsCleanupCommand } from '@cli/commands/LogsCleanupCommand';
+export { MakeMailTemplateCommand } from '@cli/commands/MakeMailTemplateCommand';
+export { MakeNotificationTemplateCommand } from '@cli/commands/MakeNotificationTemplateCommand';
+export { MigrateCommand } from '@cli/commands/MigrateCommand';
+export { MigrateWorkerCommand } from '@cli/commands/MigrateWorkerCommand';
+export { NewCommand } from '@cli/commands/NewCommand';
+export { NotificationWorkCommand } from '@cli/commands/NotificationWorkCommand';
+export { PrepareCommand } from '@cli/commands/PrepareCommand';
+export { QueueCommand } from '@cli/commands/QueueCommand';
+export { ResourceControlCommand } from '@cli/commands/ResourceControlCommand';
+export { RoutesCommand } from '@cli/commands/RoutesCommand';
+export { SecretsCommand } from '@cli/commands/SecretsCommand';
+export { StartCommand } from '@cli/commands/StartCommand';
+export { TemplatesCommand } from '@cli/commands/TemplatesCommand';

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

@@ -0,0 +1,140 @@
+export const DENO_RUNNER_SOURCE = [
+  "import http from 'node:http';",
+  "import { deno } from '@zintrust/core/start';",
+  '',
+  "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');
+
+export const LAMBDA_RUNNER_SOURCE = [
+  "import http from 'node:http';",
+  "import { handler as lambdaHandler } from '@zintrust/core/start';",
+  '',
+  "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');