@holo-js/cli 0.1.4 → 0.1.6

package/dist/chunk-DMH2B4UQ.mjs

@@ -1,343 +0,0 @@
-#!/usr/bin/env node
-import {
-  prepareProjectDiscovery
-} from "./chunk-VT5IDQG6.mjs";
-import {
-  syncManagedDriverDependencies
-} from "./chunk-QFUSWV3J.mjs";
-import {
-  ensureProjectConfig
-} from "./chunk-ET7UXHHQ.mjs";
-import {
-  readTextFile
-} from "./chunk-66FHW725.mjs";
-
-// src/dev.ts
-import { spawnSync, spawn } from "child_process";
-import { watch } from "fs";
-import { readdir, stat } from "fs/promises";
-import { dirname, join, relative, resolve } from "path";
-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 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.");
-  }
-}
-async function runProjectPrepare(projectRoot, io) {
-  const project = await ensureProjectConfig(projectRoot);
-  await prepareProjectDiscovery(projectRoot, project.config);
-  const updatedDependencies = await syncManagedDriverDependencies(projectRoot);
-  if (updatedDependencies && io) {
-    await runProjectDependencyInstall(io, projectRoot);
-    await prepareProjectDiscovery(projectRoot, project.config);
-  }
-}
-function toPosixSlashes(value) {
-  return value.replaceAll("\\", "/");
-}
-function isDiscoveryRelevantPath(filePath, project) {
-  const normalized = toPosixSlashes(filePath);
-  const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
-  const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
-  const roots = [
-    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,
-    "server/broadcast",
-    "server/channels",
-    project.config.paths.generatedSchema,
-    "config",
-    ".holo-js/generated"
-  ];
-  if (normalized === ".env" || normalized.startsWith(".env.")) {
-    return true;
-  }
-  return roots.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 authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
-  const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
-  const roots = [
-    projectRoot,
-    resolve(projectRoot, "config"),
-    resolve(projectRoot, ".holo-js/generated"),
-    resolve(projectRoot, project.config.paths.models),
-    resolve(projectRoot, project.config.paths.migrations),
-    resolve(projectRoot, project.config.paths.seeders),
-    resolve(projectRoot, project.config.paths.commands),
-    resolve(projectRoot, project.config.paths.jobs),
-    resolve(projectRoot, project.config.paths.events),
-    resolve(projectRoot, project.config.paths.listeners),
-    resolve(projectRoot, authorizationPoliciesPath),
-    resolve(projectRoot, authorizationAbilitiesPath),
-    resolve(projectRoot, "server/broadcast"),
-    resolve(projectRoot, "server/channels"),
-    dirname(resolve(projectRoot, project.config.paths.generatedSchema))
-  ];
-  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 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" || !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,
-  runProjectDependencyInstall,
-  runProjectPrepare,
-  toPosixSlashes,
-  isDiscoveryRelevantPath,
-  isRecursiveWatchUnsupported,
-  isIgnorableWatchError,
-  collectDirectoryTree,
-  collectDiscoveryWatchRoots,
-  normalizeWatchedFilePath,
-  runProjectDevServer
-};

package/dist/chunk-ET7UXHHQ.mjs

@@ -1,166 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadGeneratedProjectRegistry
-} from "./chunk-3OTCSFDG.mjs";
-import {
-  APP_CONFIG_FILE_NAMES,
-  DATABASE_CONFIG_FILE_NAMES,
-  isModulePackage,
-  pathExists,
-  resolveFirstExistingPath
-} from "./chunk-66FHW725.mjs";
-
-// src/project/config.ts
-import { mkdir, writeFile } from "fs/promises";
-import { dirname, extname, join, resolve } from "path";
-import {
-  loadConfigDirectory,
-  holoAppDefaults,
-  holoDatabaseDefaults
-} from "@holo-js/config";
-import {
-  DEFAULT_HOLO_PROJECT_PATHS,
-  normalizeHoloProjectConfig,
-  renderGeneratedSchemaPlaceholder
-} from "@holo-js/db";
-async function loadProjectConfig(projectRoot, options = {}) {
-  const appConfigPath = await resolveFirstExistingPath(projectRoot, APP_CONFIG_FILE_NAMES);
-  if (!appConfigPath) {
-    if (options.required) {
-      throw new Error(`Missing config/app.(ts|mts|js|mjs) in ${projectRoot}. Run a generator command first to create it.`);
-    }
-    return {
-      config: normalizeHoloProjectConfig()
-    };
-  }
-  const loaded = await loadConfigDirectory(projectRoot, {
-    processEnv: process.env
-  });
-  const baseConfig = normalizeHoloProjectConfig({
-    paths: loaded.app.paths,
-    database: loaded.database
-  });
-  const registry = await loadGeneratedProjectRegistry(projectRoot);
-  return {
-    manifestPath: appConfigPath,
-    config: registry ? normalizeHoloProjectConfig({
-      paths: baseConfig.paths,
-      models: registry.models.map((entry) => entry.sourcePath),
-      migrations: registry.migrations.map((entry) => entry.sourcePath),
-      seeders: registry.seeders.map((entry) => entry.sourcePath),
-      database: loaded.database
-    }) : baseConfig
-  };
-}
-async function serializeProjectConfig(projectRoot, config, manifestPath) {
-  const loaded = await loadConfigDirectory(projectRoot, {
-    processEnv: process.env
-  }).catch(() => void 0);
-  const appConfig = loaded?.app ?? holoAppDefaults;
-  const contents = JSON.stringify({
-    name: appConfig.name,
-    key: appConfig.key,
-    url: appConfig.url,
-    debug: appConfig.debug,
-    env: appConfig.env,
-    paths: config.paths
-  }, null, 2);
-  const extension = extname(manifestPath);
-  const isCommonJs = extension === ".js" && !await isModulePackage(projectRoot);
-  if (isCommonJs) {
-    return [
-      "const { defineAppConfig } = require('@holo-js/config')",
-      "",
-      "module.exports = defineAppConfig(",
-      contents,
-      ")",
-      ""
-    ].join("\n");
-  }
-  return [
-    "import { defineAppConfig } from '@holo-js/config'",
-    "",
-    "export default defineAppConfig(",
-    contents,
-    ")",
-    ""
-  ].join("\n");
-}
-async function serializeDatabaseConfig(projectRoot, _targetPath) {
-  const loaded = await loadConfigDirectory(projectRoot, {
-    processEnv: process.env
-  }).catch(() => void 0);
-  const databaseConfig = loaded?.database ?? holoDatabaseDefaults;
-  const contents = JSON.stringify({
-    defaultConnection: databaseConfig.defaultConnection,
-    connections: databaseConfig.connections
-  }, null, 2);
-  return [
-    "import { defineDatabaseConfig } from '@holo-js/config'",
-    "",
-    "export default defineDatabaseConfig(",
-    contents,
-    ")",
-    ""
-  ].join("\n");
-}
-async function writeProjectConfig(projectRoot, config, manifestPath) {
-  const targetPath = manifestPath ?? join(projectRoot, "config/app.ts");
-  await mkdir(dirname(targetPath), { recursive: true });
-  await writeFile(targetPath, await serializeProjectConfig(projectRoot, config, targetPath), "utf8");
-  return targetPath;
-}
-function resolveGeneratedSchemaPath(projectRoot, config) {
-  return resolve(projectRoot, config.paths.generatedSchema);
-}
-async function ensureGeneratedSchemaPlaceholder(projectRoot, config) {
-  const filePath = resolveGeneratedSchemaPath(projectRoot, config);
-  if (await pathExists(filePath)) {
-    return filePath;
-  }
-  await mkdir(dirname(filePath), { recursive: true });
-  await writeFile(filePath, renderGeneratedSchemaPlaceholder(), "utf8");
-  return filePath;
-}
-async function ensureProjectConfig(projectRoot) {
-  const loaded = await loadProjectConfig(projectRoot);
-  if (loaded.manifestPath) {
-    await ensureDatabaseConfig(projectRoot);
-    return loaded;
-  }
-  const manifestPath = await writeProjectConfig(projectRoot, normalizeHoloProjectConfig());
-  await ensureDatabaseConfig(projectRoot);
-  return {
-    manifestPath,
-    config: normalizeHoloProjectConfig()
-  };
-}
-async function ensureDatabaseConfig(projectRoot) {
-  const existingPath = await resolveFirstExistingPath(projectRoot, DATABASE_CONFIG_FILE_NAMES);
-  if (existingPath) {
-    return existingPath;
-  }
-  const targetPath = join(projectRoot, "config/database.ts");
-  await mkdir(dirname(targetPath), { recursive: true });
-  await writeFile(targetPath, await serializeDatabaseConfig(projectRoot, targetPath), "utf8");
-  return targetPath;
-}
-function defaultProjectConfig() {
-  return normalizeHoloProjectConfig({
-    paths: DEFAULT_HOLO_PROJECT_PATHS,
-    models: [],
-    migrations: [],
-    seeders: []
-  });
-}
-
-export {
-  loadProjectConfig,
-  serializeProjectConfig,
-  serializeDatabaseConfig,
-  writeProjectConfig,
-  resolveGeneratedSchemaPath,
-  ensureGeneratedSchemaPlaceholder,
-  ensureProjectConfig,
-  defaultProjectConfig
-};