@holo-js/cli 0.1.9 → 0.2.1

package/dist/chunk-SFRAGRHY.mjs

@@ -0,0 +1,472 @@
+import {
+  prepareProjectDiscovery
+} from "./chunk-VP2E62DF.mjs";
+import {
+  syncManagedDriverDependencies
+} from "./chunk-MCVRN7KX.mjs";
+import {
+  ensureGeneratedSchemaPlaceholder,
+  ensureProjectConfig
+} from "./chunk-YEFJBN56.mjs";
+import {
+  renderFrameworkRunner
+} from "./chunk-J76GH2DR.mjs";
+import {
+  readTextFile,
+  writeTextFile
+} from "./chunk-ILU426CF.mjs";
+
+// src/dev.ts
+import { spawnSync, spawn } from "child_process";
+import { watch } from "fs";
+import { readdir, stat } from "fs/promises";
+import { join, dirname, relative, resolve } from "path";
+import { readFile } from "fs/promises";
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveProjectPackageManager(projectRoot) {
+  const packageJsonPath = join(projectRoot, "package.json");
+  const packageJson = await readTextFile(packageJsonPath);
+  if (packageJson) {
+    try {
+      const parsed = JSON.parse(packageJson);
+      const packageManager = typeof parsed.packageManager === "string" ? parsed.packageManager.split("@")[0] : void 0;
+      if (packageManager === "bun" || packageManager === "npm" || packageManager === "pnpm" || packageManager === "yarn") {
+        return packageManager;
+      }
+    } catch {
+    }
+  }
+  if (await fileExists(join(projectRoot, "bun.lock"))) {
+    return "bun";
+  }
+  if (await fileExists(join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fileExists(join(projectRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fileExists(join(projectRoot, "package-lock.json"))) {
+    return "npm";
+  }
+  return "bun";
+}
+async function resolvePackageManagerCommand(projectRoot, scriptName) {
+  const packageManager = await resolveProjectPackageManager(projectRoot);
+  return {
+    command: packageManager,
+    args: ["run", scriptName]
+  };
+}
+async function resolvePackageManagerInstallInvocation(projectRoot) {
+  const packageManager = await resolveProjectPackageManager(projectRoot);
+  return {
+    command: packageManager,
+    args: ["install"]
+  };
+}
+async function runProjectLifecycleScript(io, projectRoot, scriptName, spawn2 = spawnSync) {
+  const invocation = await resolvePackageManagerCommand(projectRoot, scriptName);
+  const result = spawn2(invocation.command, [...invocation.args], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    env: process.env
+  });
+  if (result.stdout) {
+    io.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    io.stderr.write(result.stderr);
+  }
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `Project script "${scriptName}" failed.`);
+  }
+}
+async function runProjectStartServer(io, projectRoot, spawnProcess = spawn) {
+  const runnerPath = join(projectRoot, ".holo-js/framework/run.mjs");
+  const child = spawnProcess(process.execPath, [runnerPath, "start"], {
+    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) => {
+    child.on("error", (error) => resolvePromise({ kind: "error", error }));
+    child.on("close", (code) => resolvePromise({ kind: "close", code }));
+  });
+  if (result.kind === "error") {
+    throw result.error;
+  }
+  if (result.code !== 0) {
+    throw new Error(`Project production server failed with exit code ${result.code ?? "unknown"}.`);
+  }
+}
+async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync) {
+  const invocation = await resolvePackageManagerInstallInvocation(projectRoot);
+  const result = spawn2(invocation.command, [...invocation.args], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    env: process.env
+  });
+  if (result.stdout) {
+    io.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    io.stderr.write(result.stderr);
+  }
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || "Project dependency installation failed.");
+  }
+}
+var FRAMEWORK_SYNC_DEFINITIONS = [
+  {
+    framework: "nuxt",
+    commands: {
+      bun: ["bun", "x", "nuxt", "prepare"],
+      npm: ["npm", "exec", "--", "nuxt", "prepare"],
+      pnpm: ["pnpm", "exec", "nuxt", "prepare"],
+      yarn: ["yarn", "run", "nuxt", "prepare"]
+    },
+    errorLabel: "nuxt prepare"
+  },
+  {
+    framework: "sveltekit",
+    commands: {
+      bun: ["bun", "x", "svelte-kit", "sync"],
+      npm: ["npm", "exec", "--", "svelte-kit", "sync"],
+      pnpm: ["pnpm", "exec", "svelte-kit", "sync"],
+      yarn: ["yarn", "run", "svelte-kit", "sync"]
+    },
+    errorLabel: "svelte-kit sync"
+  }
+];
+async function runProjectPrepare(projectRoot, io, options = {}) {
+  const project = await ensureProjectConfig(projectRoot);
+  await ensureGeneratedSchemaPlaceholder(projectRoot, project.config);
+  await prepareProjectDiscovery(projectRoot, project.config);
+  await refreshFrameworkRunner(projectRoot);
+  const syncFramework = options.syncFramework ?? true;
+  if (syncFramework) {
+    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
+    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+  }
+  const updatedDependencies = await syncManagedDriverDependencies(projectRoot);
+  if (updatedDependencies && io) {
+    await runProjectDependencyInstall(io, projectRoot);
+    await prepareProjectDiscovery(projectRoot, project.config);
+    await refreshFrameworkRunner(projectRoot);
+    if (syncFramework) {
+      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
+      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+    }
+  }
+}
+async function runProjectHotPrepare(projectRoot, io) {
+  await runProjectPrepare(projectRoot, io, { syncFramework: false });
+}
+async function refreshFrameworkRunner(projectRoot) {
+  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
+  const frameworkRunnerPath = resolve(projectRoot, ".holo-js/framework/run.mjs");
+  let framework;
+  try {
+    const content = await readFile(frameworkProjectPath, "utf8");
+    const manifest = JSON.parse(content);
+    if (manifest.framework !== "next" && manifest.framework !== "nuxt" && manifest.framework !== "sveltekit") {
+      return;
+    }
+    framework = manifest.framework;
+  } catch {
+    return;
+  }
+  await writeTextFile(frameworkRunnerPath, renderFrameworkRunner({ framework }));
+}
+async function runFrameworkSync(projectRoot, definition) {
+  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
+  try {
+    const content = await readFile(frameworkProjectPath, "utf8");
+    const manifest = JSON.parse(content);
+    if (manifest.framework !== definition.framework) {
+      return;
+    }
+  } catch {
+    return;
+  }
+  const manager = await resolveProjectPackageManager(projectRoot);
+  const invocation = definition.commands[manager];
+  const command = invocation[0];
+  const args = invocation.slice(1);
+  await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2(void 0);
+      } else {
+        reject(new Error(`${definition.errorLabel} exited with ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function toPosixSlashes(value) {
+  return value.replaceAll("\\", "/");
+}
+var PACKAGE_MANIFEST_DISCOVERY_PATHS = /* @__PURE__ */ new Set([
+  "package.json",
+  "bun.lock",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+]);
+function resolveConfiguredBroadcastPath(project) {
+  const configuredPaths = project.config.paths;
+  return configuredPaths.broadcast ?? "server/broadcast";
+}
+function resolveConfiguredChannelsPath(project) {
+  const configuredPaths = project.config.paths;
+  return configuredPaths.channels ?? "server/channels";
+}
+function resolveConfiguredRealtimePath(project) {
+  const configuredPaths = project.config.paths;
+  return configuredPaths.realtime ?? "server/realtime";
+}
+function resolveConfiguredDiscoveryRoots(project) {
+  const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
+  const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
+  return [
+    project.config.paths.models,
+    project.config.paths.migrations,
+    project.config.paths.seeders,
+    project.config.paths.commands,
+    project.config.paths.jobs,
+    project.config.paths.events,
+    project.config.paths.listeners,
+    authorizationPoliciesPath,
+    authorizationAbilitiesPath,
+    resolveConfiguredBroadcastPath(project),
+    resolveConfiguredChannelsPath(project),
+    resolveConfiguredRealtimePath(project),
+    "config"
+  ];
+}
+function isDiscoveryRelevantPath(filePath, project) {
+  const normalized = toPosixSlashes(filePath);
+  if (PACKAGE_MANIFEST_DISCOVERY_PATHS.has(normalized)) {
+    return true;
+  }
+  const generatedSchemaPath = toPosixSlashes(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts");
+  if (normalized === generatedSchemaPath) {
+    return true;
+  }
+  if (normalized === ".holo-js/generated" || normalized.startsWith(".holo-js/generated/")) {
+    return false;
+  }
+  if (normalized === ".env" || normalized.startsWith(".env.")) {
+    return true;
+  }
+  return resolveConfiguredDiscoveryRoots(project).some((root) => normalized === root || normalized.startsWith(`${toPosixSlashes(root)}/`));
+}
+function isRecursiveWatchUnsupported(error) {
+  return error instanceof Error && (error.message.includes("recursive") || "code" in error && error.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM");
+}
+function isIgnorableWatchError(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EPERM");
+}
+async function collectDirectoryTree(rootPath, directories) {
+  const rootStats = await stat(rootPath).catch(() => void 0);
+  if (!rootStats?.isDirectory()) {
+    return;
+  }
+  directories.add(rootPath);
+  const entries = await readdir(rootPath, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    await collectDirectoryTree(join(rootPath, entry.name), directories);
+  }
+}
+async function collectDiscoveryWatchRoots(projectRoot, project) {
+  const directories = /* @__PURE__ */ new Set();
+  const roots = [
+    projectRoot,
+    ...resolveConfiguredDiscoveryRoots(project).map((root) => resolve(projectRoot, root)),
+    resolve(projectRoot, dirname(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts"))
+  ];
+  for (const rootPath of roots) {
+    await collectDirectoryTree(rootPath, directories);
+  }
+  return [...directories];
+}
+function normalizeWatchedFilePath(projectRoot, watchedRoot, fileName) {
+  return toPosixSlashes(relative(projectRoot, resolve(watchedRoot, fileName)));
+}
+async function runProjectDevServer(io, projectRoot, spawnProcess = spawn, createWatcher = watch, prepare = runProjectPrepare) {
+  let project = await ensureProjectConfig(projectRoot);
+  let refreshNonRecursiveWatchers;
+  let requestChildRestart;
+  const hotPrepare = prepare === runProjectPrepare ? runProjectHotPrepare : prepare;
+  const prepareDiscovery = async (syncFramework = false) => {
+    await (syncFramework ? prepare : hotPrepare)(projectRoot, io);
+    project = await ensureProjectConfig(projectRoot);
+    await refreshNonRecursiveWatchers?.();
+  };
+  await prepareDiscovery(true);
+  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" || !isDiscoveryRelevantPath(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 collectDiscoveryWatchRoots(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 (!isDiscoveryRelevantPath(normalizedPath, project)) {
+                return;
+              }
+              rerunPrepare();
+            }));
+          } catch (watchError) {
+            if (!isIgnorableWatchError(watchError)) {
+              throw watchError;
+            }
+          }
+        }
+      };
+      return () => closeAllWatchers();
+    }
+  })();
+  await refreshNonRecursiveWatchers?.();
+  const invocation = await resolvePackageManagerCommand(projectRoot, "holo:dev");
+  while (!shuttingDown) {
+    const child = spawnProcess(invocation.command, [...invocation.args], {
+      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) => {
+        if (child.stdin) {
+          io.stdin.unpipe(child.stdin);
+        }
+        requestChildRestart = void 0;
+        if (restartRequested) {
+          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(`Project script "holo:dev" failed with exit code ${result.code ?? "unknown"}.`);
+  }
+}
+
+export {
+  resolveProjectPackageManager,
+  resolvePackageManagerCommand,
+  resolvePackageManagerInstallInvocation,
+  runProjectLifecycleScript,
+  runProjectStartServer,
+  runProjectDependencyInstall,
+  runProjectPrepare,
+  toPosixSlashes,
+  isDiscoveryRelevantPath,
+  isRecursiveWatchUnsupported,
+  isIgnorableWatchError,
+  collectDirectoryTree,
+  collectDiscoveryWatchRoots,
+  normalizeWatchedFilePath,
+  runProjectDevServer
+};

package/dist/{chunk-7JR73TOH.mjs → chunk-VP2E62DF.mjs}

@@ -1,7 +1,7 @@
 import {
   loadGeneratedProjectRegistry,
   writeGeneratedProjectRegistry
-} from "./chunk-IMOGEKB4.mjs";
+} from "./chunk-J76GH2DR.mjs";
 import {
   COMMAND_FILE_PATTERN,
   MIGRATION_NAME_PATTERN,
@@ -17,7 +17,7 @@ import {
   pathExists,
   readTextFile,
   toPosixPath
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/project/discovery.ts
 import { resolve as resolve2 } from "path";
@@ -55,37 +55,25 @@ function deriveJobNameFromPath(jobsRoot, sourcePath) {
   const relativePath = toPosixPath(relative(jobsRoot, sourcePath));
   return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(".");
 }
-function deriveEventNameFromPath(eventsRoot, sourcePath) {
-  const relativePath = toPosixPath(relative(eventsRoot, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
+function deriveDottedNameFromPath(root, sourcePath, emptyMessage) {
+  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
   const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
   if (!derived) {
-    throw new Error("[Holo Events] Derived event names require a non-empty source path.");
+    throw new Error(emptyMessage);
   }
   return derived;
 }
+function deriveEventNameFromPath(eventsRoot, sourcePath) {
+  return deriveDottedNameFromPath(eventsRoot, sourcePath, "[Holo Events] Derived event names require a non-empty source path.");
+}
 function deriveListenerIdFromPath(listenersRoot, sourcePath) {
-  const relativePath = toPosixPath(relative(listenersRoot, sourcePath));
-  const derived = relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error("[Holo Events] Derived listener identifiers require a non-empty source path.");
-  }
-  return derived;
+  return deriveDottedNameFromPath(listenersRoot, sourcePath, "[Holo Events] Derived listener identifiers require a non-empty source path.");
 }
 function deriveBroadcastNameFromPath(root, sourcePath) {
-  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
-  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error("[Holo Broadcast] Derived broadcast names require a non-empty source path.");
-  }
-  return derived;
+  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived broadcast names require a non-empty source path.");
 }
 function deriveChannelPatternFromPath(root, sourcePath) {
-  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
-  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error("[Holo Broadcast] Derived channel patterns require a non-empty source path.");
-  }
-  return derived;
+  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived channel patterns require a non-empty source path.");
 }
 function resolveDiscoveredJobMetadata(job, sourcePath, derivedName, queueConfig) {
   const connection = job.connection ?? queueConfig.default;
@@ -356,6 +344,28 @@ function validateMigrationName(name, message) {
 }
 
 // src/project/discovery.ts
+function resolveBroadcastExportEntry(moduleValue, discovery) {
+  if (!moduleValue || typeof moduleValue !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(moduleValue);
+  const orderedEntries = "default" in moduleValue ? [
+    ["default", moduleValue.default],
+    ...entries.filter(([exportName]) => exportName !== "default")
+  ] : entries;
+  for (const [exportName, value] of orderedEntries) {
+    if (discovery.isBroadcastDefinition(value)) {
+      return { exportName, value };
+    }
+    if (typeof value === "function") {
+      const resolved = value(...Array.from({ length: value.length }, () => "__holo_discovery__"));
+      if (discovery.isBroadcastDefinition(resolved)) {
+        return { exportName, value: resolved };
+      }
+    }
+  }
+  return void 0;
+}
 async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjectConfig()) {
   const loadedConfig = await loadConfigDirectory(projectRoot, {
     processEnv: process.env
@@ -565,9 +575,9 @@ async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjec
   const broadcast = [];
   for (const filePath of broadcastFiles) {
     const relativePath = makeProjectRelativePath(projectRoot, filePath);
-    const exportedBroadcast = resolveNamedExportEntry(
+    const exportedBroadcast = resolveBroadcastExportEntry(
       await importProjectModule(projectRoot, filePath),
-      (value) => broadcastDiscovery.isBroadcastDefinition(value)
+      broadcastDiscovery
     );
     if (!exportedBroadcast) {
       throw new Error(`Discovered broadcast "${relativePath}" does not export a Holo broadcast definition.`);
@@ -601,6 +611,7 @@ async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjec
       sourcePath: relativePath,
       pattern,
       exportName: exportedChannel.exportName,
+      ...typeof normalizedChannel.guard === "string" ? { guard: normalizedChannel.guard } : {},
       type: normalizedChannel.type,
       params: broadcastDiscovery.broadcastInternals.extractChannelPatternParamNames(pattern),
       whispers: Object.freeze(Object.keys(normalizedChannel.whispers))