@holo-js/cli 0.1.2 → 0.1.4

package/dist/queue-FV35LLPR.mjs

@@ -0,0 +1,625 @@
+import {
+  writeLine
+} from "./chunk-ZXDU7RHU.mjs";
+import {
+  initializeProjectRuntime
+} from "./chunk-URK7C3VQ.mjs";
+import "./chunk-EUIVXVJL.mjs";
+import {
+  isIgnorableWatchError,
+  isRecursiveWatchUnsupported,
+  normalizeWatchedFilePath,
+  runProjectPrepare,
+  toPosixSlashes
+} from "./chunk-ZLRO7HXY.mjs";
+import "./chunk-CUL4RJTG.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-S7P7EBM3.mjs";
+import "./chunk-MZXN2YMI.mjs";
+import {
+  ensureProjectConfig,
+  loadProjectConfig
+} from "./chunk-GSQ3HTRO.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-H7TJ4FB3.mjs";
+import {
+  HOLO_RUNTIME_ROOT,
+  bundleProjectModule,
+  resolveProjectPackageImportSpecifier
+} from "./chunk-G5ADO27Q.mjs";
+
+// src/queue.ts
+import { spawn } from "child_process";
+import { existsSync, watch } from "fs";
+import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname, extname, join, relative, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { loadConfigDirectory } from "@holo-js/config";
+import {
+  configureDB,
+  resetDB,
+  resolveRuntimeConnectionManagerOptions
+} from "@holo-js/db";
+var QUEUE_LISTEN_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".cjs",
+  ".cts",
+  ".js",
+  ".json",
+  ".jsx",
+  ".mjs",
+  ".mts",
+  ".ts",
+  ".tsx"
+]);
+var QUEUE_LISTEN_IGNORED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".svelte-kit",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var QUEUE_LISTEN_IGNORED_PATH_PREFIXES = [
+  HOLO_RUNTIME_ROOT
+].map(toPosixSlashes);
+async function loadQueueCliModule(projectRoot) {
+  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/queue"));
+}
+function isIgnoredQueueListenPath(filePath) {
+  const normalized = toPosixSlashes(filePath);
+  if (QUEUE_LISTEN_IGNORED_PATH_PREFIXES.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`))) {
+    return true;
+  }
+  return normalized.split("/").filter(Boolean).some((segment) => QUEUE_LISTEN_IGNORED_DIRECTORY_NAMES.has(segment));
+}
+async function collectQueueWatchTree(rootPath, directories, projectRoot, project) {
+  const relativePath = toPosixSlashes(relative(projectRoot, rootPath));
+  if (relativePath && isIgnoredQueueListenPath(relativePath)) {
+    return false;
+  }
+  const rootStats = await stat(rootPath).catch(() => void 0);
+  if (!rootStats?.isDirectory()) {
+    return false;
+  }
+  let shouldWatchDirectory = relativePath === "" || isQueueListenRelevantPath(relativePath, project);
+  const entries = await readdir(rootPath, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    const entryPath = join(rootPath, entry.name);
+    if (!entry.isDirectory()) {
+      if (entry.isFile()) {
+        const normalizedPath = toPosixSlashes(relative(projectRoot, entryPath));
+        if (isQueueListenRelevantPath(normalizedPath, project)) {
+          shouldWatchDirectory = true;
+        }
+      }
+      continue;
+    }
+    if (await collectQueueWatchTree(entryPath, directories, projectRoot, project)) {
+      shouldWatchDirectory = true;
+    }
+  }
+  if (shouldWatchDirectory) {
+    directories.add(rootPath);
+  }
+  return shouldWatchDirectory;
+}
+function isQueueListenRelevantPath(filePath, project) {
+  const normalized = toPosixSlashes(filePath);
+  const roots = [
+    project.config.paths.models,
+    project.config.paths.jobs,
+    project.config.paths.events,
+    project.config.paths.listeners,
+    "config",
+    ".holo-js/generated"
+  ];
+  if (normalized === ".env" || normalized.startsWith(".env.")) {
+    return true;
+  }
+  if (isIgnoredQueueListenPath(normalized)) {
+    return false;
+  }
+  if (roots.some((root) => normalized === root || normalized.startsWith(`${toPosixSlashes(root)}/`))) {
+    return true;
+  }
+  return QUEUE_LISTEN_SOURCE_EXTENSIONS.has(extname(normalized).toLowerCase());
+}
+async function collectQueueWatchRoots(projectRoot, project) {
+  const directories = /* @__PURE__ */ new Set();
+  await collectQueueWatchTree(projectRoot, directories, projectRoot, project);
+  return [...directories];
+}
+function resolveCliEntrypointPath() {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const builtEntry = resolve(currentDir, "bin", "holo.mjs");
+  if (existsSync(builtEntry)) {
+    return builtEntry;
+  }
+  return resolve(currentDir, "bin", "holo.ts");
+}
+async function resolveRunnableCliEntrypoint() {
+  const cliEntrypoint = resolveCliEntrypointPath();
+  const extension = extname(cliEntrypoint).toLowerCase();
+  if (extension !== ".ts" && extension !== ".mts" && extension !== ".cts") {
+    return {
+      path: cliEntrypoint,
+      async cleanup() {
+      }
+    };
+  }
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const workspaceRoot = resolve(currentDir, "..", "..", "..");
+  return bundleProjectModule(workspaceRoot, cliEntrypoint);
+}
+function isModuleRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function resolveModuleExport(moduleValue, matcher) {
+  if (!isModuleRecord(moduleValue)) return void 0;
+  if (matcher(moduleValue.default)) return moduleValue.default;
+  for (const value of Object.values(moduleValue)) {
+    if (matcher(value)) return value;
+  }
+  return void 0;
+}
+function buildQueueWorkArgs(flags) {
+  const args = ["queue:work"];
+  for (const [name, value] of Object.entries(flags)) {
+    if (name === "help" || name === "h") {
+      continue;
+    }
+    if (value === false) {
+      continue;
+    }
+    const optionName = name.length === 1 ? `-${name}` : `--${name}`;
+    if (value === true) {
+      args.push(optionName);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        args.push(optionName, entry);
+      }
+      continue;
+    }
+    args.push(optionName, String(value));
+  }
+  return args;
+}
+function resolveQueueRestartSignalPath(projectRoot) {
+  return resolve(projectRoot, ".holo-js", "runtime", "queue-restart.signal");
+}
+async function readQueueRestartSignal(projectRoot) {
+  const contents = await readFile(resolveQueueRestartSignalPath(projectRoot), "utf8").catch(() => void 0);
+  if (!contents) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(contents.trim(), 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+async function writeQueueRestartSignal(projectRoot, timestamp = Date.now()) {
+  const signalPath = resolveQueueRestartSignalPath(projectRoot);
+  await mkdir(dirname(signalPath), { recursive: true });
+  await writeFile(signalPath, `${timestamp}
+`, "utf8");
+  return signalPath;
+}
+async function hasQueueRestartSignalSince(projectRoot, since) {
+  const signal = await readQueueRestartSignal(projectRoot);
+  return typeof signal === "number" && signal > since;
+}
+async function getQueueRuntimeEnvironment(projectRoot) {
+  let project = await loadProjectConfig(projectRoot, { required: true });
+  await prepareProjectDiscovery(projectRoot, project.config);
+  project = await loadProjectConfig(projectRoot, { required: true });
+  const runtime = await initializeProjectRuntime(projectRoot, {
+    registerProjectQueueJobs: false
+  });
+  const registry = await loadGeneratedProjectRegistry(projectRoot);
+  const modelEntries = registry?.models ?? [];
+  const jobEntries = registry?.jobs ?? [];
+  const bundledModels = [];
+  const bundledJobs = [];
+  try {
+    const queueModule = jobEntries.length > 0 ? await loadQueueCliModule(projectRoot) : void 0;
+    for (const entry of modelEntries) {
+      bundledModels.push(await bundleProjectModule(
+        projectRoot,
+        resolve(projectRoot, entry.sourcePath)
+      ));
+    }
+    for (const entry of jobEntries) {
+      if (queueModule?.getRegisteredQueueJob(entry.name)) {
+        continue;
+      }
+      bundledJobs.push(await bundleProjectModule(
+        projectRoot,
+        resolve(projectRoot, entry.sourcePath),
+        { external: ["@holo-js/queue"] }
+      ));
+    }
+    for (let index = 0; index < modelEntries.length; index += 1) {
+      const bundledEntry = bundledModels[index];
+      await import(`${pathToFileURL(bundledEntry.path).href}?t=${Date.now()}-model-${index}`);
+    }
+    let bundledJobIndex = 0;
+    for (let index = 0; index < jobEntries.length; index += 1) {
+      const entry = jobEntries[index];
+      if (queueModule?.getRegisteredQueueJob(entry.name)) {
+        continue;
+      }
+      const bundledEntry = bundledJobs[bundledJobIndex];
+      bundledJobIndex += 1;
+      const moduleValue = await import(`${pathToFileURL(bundledEntry.path).href}?t=${Date.now()}-${index}`);
+      const job = resolveModuleExport(moduleValue, (value) => queueModule.isQueueJobDefinition(value));
+      if (!job) {
+        throw new Error(`Discovered job "${entry.sourcePath}" does not export a Holo job.`);
+      }
+      if (!queueModule?.getRegisteredQueueJob(entry.name)) {
+        queueModule.registerQueueJob(queueModule.normalizeQueueJobDefinition(job), {
+          name: entry.name,
+          sourcePath: entry.sourcePath
+        });
+      }
+    }
+  } catch (error) {
+    await runtime.shutdown().catch(() => {
+    });
+    await Promise.all([...bundledModels, ...bundledJobs].map((entry) => entry.cleanup()));
+    throw error;
+  }
+  return {
+    runtime,
+    project,
+    bundledJobs: bundledJobs.map((entry) => entry.path),
+    async cleanup() {
+      await Promise.all([...bundledModels, ...bundledJobs].map((entry) => entry.cleanup()));
+      await runtime.shutdown();
+    }
+  };
+}
+async function runQueueWorkCommand(io, projectRoot, options, dependencies = {}) {
+  const startedAt = Date.now();
+  const environment = await (dependencies.getEnvironment ?? getQueueRuntimeEnvironment)(projectRoot);
+  try {
+    const queueModule = dependencies.runWorker ? void 0 : await loadQueueCliModule(projectRoot);
+    const result = await (dependencies.runWorker ?? queueModule.runQueueWorker)({
+      ...options,
+      shouldStop: async () => {
+        if (await options.shouldStop?.()) {
+          return true;
+        }
+        return (dependencies.hasRestartSignal ?? hasQueueRestartSignalSince)(projectRoot, startedAt);
+      },
+      onJobFailed: async (event) => {
+        await options.onJobFailed?.(event);
+        writeLine(io.stderr, `[queue] Failed ${event.jobName} (${event.jobId}): ${event.error.message}`);
+      }
+    });
+    writeLine(
+      io.stdout,
+      `[queue] Stopped (${result.stoppedBecause}). processed=${result.processed} released=${result.released} failed=${result.failed}`
+    );
+  } finally {
+    await environment.cleanup();
+  }
+}
+async function initializeQueueMaintenanceEnvironment(projectRoot, connectionName) {
+  const loadedConfig = await loadConfigDirectory(projectRoot);
+  const queueModule = await loadQueueCliModule(projectRoot);
+  const resolvedConnectionName = connectionName?.trim() || loadedConfig.queue.default;
+  const connection = loadedConfig.queue.connections[resolvedConnectionName];
+  if (!connection || connection.driver !== "database") {
+    queueModule.configureQueueRuntime({
+      config: loadedConfig.queue,
+      redisConfig: loadedConfig.redis
+    });
+    return {
+      async cleanup() {
+        await queueModule.shutdownQueueRuntime();
+      }
+    };
+  }
+  const { createQueueDbRuntimeOptions } = await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/queue-db"));
+  queueModule.configureQueueRuntime({
+    config: loadedConfig.queue,
+    redisConfig: loadedConfig.redis,
+    ...createQueueDbRuntimeOptions()
+  });
+  const manager = resolveRuntimeConnectionManagerOptions({
+    db: loadedConfig.database
+  });
+  configureDB(manager);
+  try {
+    await manager.initializeAll();
+  } catch (error) {
+    await manager.disconnectAll().catch(() => {
+    });
+    resetDB();
+    await queueModule.shutdownQueueRuntime();
+    throw error;
+  }
+  return {
+    async cleanup() {
+      try {
+        await manager.disconnectAll();
+      } finally {
+        resetDB();
+        await queueModule.shutdownQueueRuntime();
+      }
+    }
+  };
+}
+async function runQueueClearCommand(io, projectRoot, connectionName, queueNames, dependencies = {}) {
+  if (dependencies.initialize) {
+    const runtime = await dependencies.initialize(projectRoot);
+    const queueModule = dependencies.clear ? void 0 : await loadQueueCliModule(projectRoot);
+    try {
+      const cleared = await (dependencies.clear ?? queueModule.clearQueueConnection)(connectionName, {
+        ...queueNames && queueNames.length > 0 ? { queueNames } : {}
+      });
+      writeLine(io.stdout, `[queue] Cleared ${cleared} pending job(s).`);
+    } finally {
+      await runtime.shutdown();
+    }
+    return;
+  }
+  const environment = await (dependencies.initializeQueue ?? initializeQueueMaintenanceEnvironment)(
+    projectRoot,
+    connectionName
+  );
+  try {
+    const queueModule = dependencies.clear ? void 0 : await loadQueueCliModule(projectRoot);
+    const cleared = await (dependencies.clear ?? queueModule.clearQueueConnection)(connectionName, {
+      ...queueNames && queueNames.length > 0 ? { queueNames } : {}
+    });
+    writeLine(io.stdout, `[queue] Cleared ${cleared} pending job(s).`);
+  } finally {
+    await environment.cleanup();
+  }
+}
+async function runQueueRestartCommand(io, projectRoot) {
+  const signalPath = await writeQueueRestartSignal(projectRoot);
+  writeLine(io.stdout, `[queue] Restart signal written: ${signalPath}`);
+}
+async function runQueueListen(io, projectRoot, flags, spawnProcess = spawn, createWatcher = watch, prepare = runProjectPrepare) {
+  let project = await ensureProjectConfig(projectRoot);
+  let refreshNonRecursiveWatchers;
+  let requestChildRestart;
+  const childArgs = buildQueueWorkArgs(flags);
+  const cliEntrypoint = await resolveRunnableCliEntrypoint();
+  try {
+    const prepareDiscovery = async () => {
+      await prepare(projectRoot, io);
+      project = await ensureProjectConfig(projectRoot);
+      await refreshNonRecursiveWatchers?.();
+    };
+    await prepareDiscovery();
+    let pendingPrepare;
+    let queued = false;
+    let shuttingDown = false;
+    const rerunPrepare = () => {
+      if (shuttingDown) {
+        return;
+      }
+      if (pendingPrepare) {
+        queued = true;
+        return;
+      }
+      pendingPrepare = prepareDiscovery().then(() => {
+        requestChildRestart?.();
+      }).catch((error) => {
+        io.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+      }).finally(() => {
+        pendingPrepare = void 0;
+        if (queued) {
+          queued = false;
+          rerunPrepare();
+        }
+      });
+    };
+    const closeWatchers = (() => {
+      try {
+        const watcher = createWatcher(projectRoot, { recursive: true }, (_eventType, fileName) => {
+          if (shuttingDown || typeof fileName !== "string" || !isQueueListenRelevantPath(fileName, project)) {
+            return;
+          }
+          rerunPrepare();
+        });
+        return () => watcher.close();
+      } catch (error) {
+        if (!isRecursiveWatchUnsupported(error)) {
+          throw error;
+        }
+        const watchers = [];
+        const closeAllWatchers = () => {
+          while (watchers.length > 0) {
+            watchers.pop()?.close();
+          }
+        };
+        refreshNonRecursiveWatchers = async () => {
+          closeAllWatchers();
+          const watchRoots = await collectQueueWatchRoots(projectRoot, project);
+          for (const watchRoot of watchRoots) {
+            try {
+              watchers.push(createWatcher(watchRoot, { recursive: false }, (_eventType, fileName) => {
+                if (shuttingDown || typeof fileName !== "string") {
+                  return;
+                }
+                const normalizedPath = normalizeWatchedFilePath(projectRoot, watchRoot, fileName);
+                if (!isQueueListenRelevantPath(normalizedPath, project)) {
+                  return;
+                }
+                rerunPrepare();
+              }));
+            } catch (watchError) {
+              if (!isIgnorableWatchError(watchError)) {
+                throw watchError;
+              }
+            }
+          }
+        };
+        return () => closeAllWatchers();
+      }
+    })();
+    await refreshNonRecursiveWatchers?.();
+    while (!shuttingDown) {
+      const childStartedAt = Date.now();
+      const child = spawnProcess(process.execPath, [cliEntrypoint.path, ...childArgs], {
+        cwd: projectRoot,
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      child.stdout?.on("data", (chunk) => io.stdout.write(chunk));
+      child.stderr?.on("data", (chunk) => io.stderr.write(chunk));
+      if (child.stdin) {
+        io.stdin.pipe(child.stdin);
+      }
+      const result = await new Promise((resolvePromise) => {
+        let restartRequested = false;
+        requestChildRestart = () => {
+          if (restartRequested || shuttingDown || typeof child.kill !== "function") {
+            return;
+          }
+          restartRequested = true;
+          child.kill("SIGTERM");
+        };
+        child.on("error", (error) => {
+          if (child.stdin) {
+            io.stdin.unpipe(child.stdin);
+          }
+          requestChildRestart = void 0;
+          if (restartRequested) {
+            resolvePromise({ kind: "restart" });
+            return;
+          }
+          resolvePromise({ kind: "error", error });
+        });
+        child.on("close", (code) => {
+          void (async () => {
+            if (child.stdin) {
+              io.stdin.unpipe(child.stdin);
+            }
+            requestChildRestart = void 0;
+            if (restartRequested) {
+              resolvePromise({ kind: "restart" });
+              return;
+            }
+            if (!shuttingDown && code === 0 && await hasQueueRestartSignalSince(projectRoot, childStartedAt)) {
+              resolvePromise({ kind: "restart" });
+              return;
+            }
+            resolvePromise({ kind: "close", code });
+          })();
+        });
+      });
+      if (result.kind === "restart") {
+        continue;
+      }
+      shuttingDown = true;
+      closeWatchers();
+      await Promise.resolve(pendingPrepare);
+      if (result.kind === "error") {
+        throw result.error;
+      }
+      if (result.code === 0) {
+        return;
+      }
+      throw new Error(`Queue worker failed with exit code ${result.code ?? "unknown"}.`);
+    }
+  } finally {
+    await cliEntrypoint.cleanup();
+  }
+}
+async function runQueueFailedCommand(io, projectRoot, dependencies = {}) {
+  const runtime = await (dependencies.initialize ?? initializeProjectRuntime)(projectRoot, {
+    registerProjectQueueJobs: false
+  });
+  try {
+    const queueModule = dependencies.list ? void 0 : await loadQueueCliModule(projectRoot);
+    const failedJobs = await (dependencies.list ?? queueModule.listFailedQueueJobs)();
+    if (failedJobs.length === 0) {
+      writeLine(io.stdout, "[queue] No failed jobs.");
+      return;
+    }
+    for (const job of failedJobs) {
+      writeLine(
+        io.stdout,
+        `${job.id} ${job.job.name} connection=${job.job.connection} queue=${job.job.queue} failedAt=${job.failedAt}`
+      );
+    }
+  } finally {
+    await runtime.shutdown();
+  }
+}
+async function runQueueRetryCommand(io, projectRoot, identifier, dependencies = {}) {
+  const runtime = await (dependencies.initialize ?? initializeProjectRuntime)(projectRoot, {
+    registerProjectQueueJobs: false
+  });
+  try {
+    const queueModule = dependencies.retry ? void 0 : await loadQueueCliModule(projectRoot);
+    const retried = await (dependencies.retry ?? queueModule.retryFailedQueueJobs)(identifier);
+    writeLine(io.stdout, `[queue] Retried ${retried} failed job(s).`);
+  } finally {
+    await runtime.shutdown();
+  }
+}
+async function runQueueForgetCommand(io, projectRoot, identifier, dependencies = {}) {
+  const runtime = await (dependencies.initialize ?? initializeProjectRuntime)(projectRoot, {
+    registerProjectQueueJobs: false
+  });
+  try {
+    const queueModule = dependencies.forget ? void 0 : await loadQueueCliModule(projectRoot);
+    const forgotten = await (dependencies.forget ?? queueModule.forgetFailedQueueJob)(identifier);
+    writeLine(io.stdout, forgotten ? `[queue] Forgot failed job ${identifier}.` : `[queue] Failed job ${identifier} was not found.`);
+  } finally {
+    await runtime.shutdown();
+  }
+}
+async function runQueueFlushCommand(io, projectRoot, dependencies = {}) {
+  const runtime = await (dependencies.initialize ?? initializeProjectRuntime)(projectRoot, {
+    registerProjectQueueJobs: false
+  });
+  try {
+    const queueModule = dependencies.flush ? void 0 : await loadQueueCliModule(projectRoot);
+    const flushed = await (dependencies.flush ?? queueModule.flushFailedQueueJobs)();
+    writeLine(io.stdout, `[queue] Flushed ${flushed} failed job(s).`);
+  } finally {
+    await runtime.shutdown();
+  }
+}
+export {
+  QUEUE_LISTEN_IGNORED_DIRECTORY_NAMES,
+  QUEUE_LISTEN_IGNORED_PATH_PREFIXES,
+  QUEUE_LISTEN_SOURCE_EXTENSIONS,
+  buildQueueWorkArgs,
+  collectQueueWatchRoots,
+  collectQueueWatchTree,
+  getQueueRuntimeEnvironment,
+  hasQueueRestartSignalSince,
+  initializeQueueMaintenanceEnvironment,
+  isIgnoredQueueListenPath,
+  isModuleRecord,
+  isQueueListenRelevantPath,
+  loadQueueCliModule,
+  readQueueRestartSignal,
+  resolveCliEntrypointPath,
+  resolveModuleExport,
+  resolveQueueRestartSignalPath,
+  resolveRunnableCliEntrypoint,
+  runQueueClearCommand,
+  runQueueFailedCommand,
+  runQueueFlushCommand,
+  runQueueForgetCommand,
+  runQueueListen,
+  runQueueRestartCommand,
+  runQueueRetryCommand,
+  runQueueWorkCommand,
+  writeQueueRestartSignal
+};