@holo-js/cli 0.2.5 → 0.3.0

package/dist/chunk-LALDNNPH.mjs

@@ -0,0 +1,428 @@
+import {
+  fileExists
+} from "./chunk-M3IPUCTM.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-QSVMXMTQ.mjs";
+import {
+  loadProjectConfig,
+  resolveGeneratedSchemaPath
+} from "./chunk-JVLZ3SOW.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-R4ZYMEDU.mjs";
+import {
+  CLI_RUNTIME_ROOT,
+  GENERATED_SCHEMA_RUNTIME_PATH,
+  bundleProjectModule
+} from "./chunk-YACY2572.mjs";
+
+// src/runtime.ts
+import { spawn } from "child_process";
+import { mkdir, readFile, rm, symlink, writeFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { setTimeout } from "timers/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+import { writeConfigCache } from "@holo-js/config";
+var runtimeImportMeta = import.meta;
+var RUNTIME_DEPENDENCY_LOCK_RETRY_MS = 10;
+function resolveConfigModuleUrl(runtimeResolve = runtimeImportMeta.resolve?.bind(runtimeImportMeta)) {
+  if (typeof runtimeResolve === "function") {
+    const resolved = runtimeResolve("@holo-js/config");
+    if (resolved.startsWith("file://")) {
+      const resolvedPath = fileURLToPath(resolved);
+      const normalized = resolvedPath.replace(/\\/g, "/");
+      if (normalized.endsWith("/src/index.ts") || normalized.endsWith("/src/index.mts") || normalized.endsWith("/src/index.js") || normalized.endsWith("/src/index.mjs")) {
+        return pathToFileURL(resolve(dirname(dirname(resolvedPath)), "dist/index.mjs")).href;
+      }
+    }
+    return resolved;
+  }
+  return pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), "../node_modules/@holo-js/config/dist/index.mjs")).href;
+}
+async function initializeProjectRuntime(projectRoot, options = {}) {
+  const { initializeHolo } = await import("@holo-js/core");
+  return initializeHolo(projectRoot, options);
+}
+function parseBooleanEnv(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+async function cacheProjectConfig(projectRoot, cacheWriter = writeConfigCache) {
+  try {
+    return await cacheWriter(projectRoot, { processEnv: process.env });
+  } catch (error) {
+    throw new Error(error instanceof Error && error.message ? error.message : "Failed to cache config.");
+  }
+}
+function createEnvRuntimeConfig() {
+  return {
+    db: {
+      defaultConnection: "default",
+      connections: {
+        default: {
+          driver: process.env.DB_DRIVER,
+          url: process.env.DB_URL,
+          host: process.env.DB_HOST,
+          port: process.env.DB_PORT,
+          username: process.env.DB_USERNAME,
+          password: process.env.DB_PASSWORD,
+          database: process.env.DB_DATABASE,
+          schema: process.env.DB_SCHEMA,
+          ssl: parseBooleanEnv(process.env.DB_SSL),
+          logging: parseBooleanEnv(process.env.DB_LOGGING)
+        }
+      }
+    }
+  };
+}
+function normalizeRuntimeConnectionInput(connection) {
+  if (typeof connection === "string") {
+    return { url: connection };
+  }
+  return connection ? { ...connection } : {};
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+function filterDefinedRuntimeConnectionInput(connection) {
+  return Object.fromEntries(
+    Object.entries(connection).filter(([, value]) => isDefined(value))
+  );
+}
+function mergeRuntimeDatabaseConfig(config, envRuntimeConfig) {
+  const envDefault = envRuntimeConfig.db.connections.default;
+  const hasEnvOverrides = Object.values(envDefault).some(isDefined);
+  if (!config) {
+    return envRuntimeConfig.db;
+  }
+  if (!hasEnvOverrides) {
+    return config;
+  }
+  const defaultConnection = config.defaultConnection ?? "default";
+  const connections = { ...config.connections ?? {} };
+  connections[defaultConnection] = {
+    ...normalizeRuntimeConnectionInput(connections[defaultConnection]),
+    ...filterDefinedRuntimeConnectionInput(envDefault)
+  };
+  return {
+    ...config,
+    defaultConnection,
+    connections
+  };
+}
+var RUNTIME_MIGRATION_NAME_PATTERN = /^\d{4}_\d{2}_\d{2}_\d{6}_[a-z0-9_]+$/;
+function inferRuntimeMigrationName(entry) {
+  const fileName = entry.split("/").pop()?.replace(/\.[^.]+$/, "");
+  if (!fileName || !RUNTIME_MIGRATION_NAME_PATTERN.test(fileName)) {
+    throw new Error(`Registered migration "${entry}" must use a timestamped file name matching YYYY_MM_DD_HHMMSS_description.`);
+  }
+  return fileName;
+}
+function normalizeRuntimeMigration(entry, migration) {
+  return {
+    ...migration,
+    name: typeof migration.name === "string" ? migration.name : inferRuntimeMigrationName(entry)
+  };
+}
+function compileFreshDropIdentifierPath(quoteIdentifier, identifier) {
+  if (!identifier.includes(".")) {
+    return quoteIdentifier(identifier);
+  }
+  return identifier.split(".").map((part) => quoteIdentifier(part)).join(".");
+}
+async function dropAllTablesForFresh(connection, schema) {
+  const tables = await schema.getTables();
+  if (connection.getDialect().name === "postgres") {
+    const schemaName = connection.getSchemaName();
+    const quoteIdentifier = connection.getDialect().quoteIdentifier;
+    for (const tableName of tables) {
+      const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+      await connection.executeCompiled({
+        sql: `DROP TABLE IF EXISTS ${compileFreshDropIdentifierPath(quoteIdentifier, qualifiedTableName)} CASCADE`,
+        source: `schema:dropTableFresh:${qualifiedTableName}`
+      });
+    }
+    return;
+  }
+  await schema.withoutForeignKeyConstraints(async () => {
+    for (const tableName of tables) {
+      await schema.dropTable(tableName);
+    }
+  });
+}
+async function getRuntimeEnvironment(projectRoot) {
+  let project = await loadProjectConfig(projectRoot, { required: true });
+  if (!await loadGeneratedProjectRegistry(projectRoot)) {
+    await prepareProjectDiscovery(projectRoot, project.config);
+    project = await loadProjectConfig(projectRoot, { required: true });
+  }
+  const generatedSchemaPath = resolveGeneratedSchemaPath(projectRoot, project.config);
+  const hasGeneratedSchema = await fileExists(generatedSchemaPath);
+  const bundleInputs = [
+    ...project.config.models.map((entry) => resolve(projectRoot, entry)),
+    ...project.config.migrations.map((entry) => resolve(projectRoot, entry)),
+    ...project.config.seeders.map((entry) => resolve(projectRoot, entry)),
+    ...hasGeneratedSchema ? [generatedSchemaPath] : []
+  ];
+  const bundled = [];
+  try {
+    for (const entryPath of bundleInputs) {
+      bundled.push(await bundleProjectModule(projectRoot, entryPath, { external: ["@holo-js/db"] }));
+    }
+  } catch (error) {
+    await Promise.all(bundled.map((entry) => entry.cleanup()));
+    throw error;
+  }
+  const bundledModels = bundled.slice(0, project.config.models.length).map((entry) => entry.path);
+  const bundledMigrations = bundled.slice(project.config.models.length, project.config.models.length + project.config.migrations.length).map((entry) => entry.path);
+  const bundledSeeders = bundled.slice(project.config.models.length + project.config.migrations.length).slice(0, project.config.seeders.length).map((entry) => entry.path);
+  const bundledGeneratedSchema = hasGeneratedSchema ? bundled[project.config.models.length + project.config.migrations.length + project.config.seeders.length]?.path : void 0;
+  return {
+    project,
+    bundledModels,
+    bundledMigrations,
+    bundledSeeders,
+    ...bundledGeneratedSchema ? { bundledGeneratedSchema } : {},
+    async cleanup() {
+      await Promise.all(bundled.map((entry) => entry.cleanup()));
+    }
+  };
+}
+async function resolvePackageRootFromSpecifier(specifier) {
+  let current = dirname(fileURLToPath(import.meta.resolve(specifier)));
+  while (true) {
+    if (await fileExists(join(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      throw new Error(`Could not resolve package root for "${specifier}".`);
+    }
+    current = parent;
+  }
+}
+function isFileExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function withRuntimeDependencyLock(projectRoot, callback) {
+  const runtimeRoot = join(projectRoot, CLI_RUNTIME_ROOT);
+  const lockDir = join(runtimeRoot, "node_modules.lock");
+  await mkdir(runtimeRoot, { recursive: true });
+  while (true) {
+    try {
+      await mkdir(lockDir);
+      break;
+    } catch (error) {
+      if (!isFileExistsError(error)) {
+        throw error;
+      }
+      await setTimeout(RUNTIME_DEPENDENCY_LOCK_RETRY_MS);
+    }
+  }
+  try {
+    return await callback();
+  } finally {
+    await rm(lockDir, { recursive: true, force: true });
+  }
+}
+async function readRuntimeDependencyReferenceCount(refPath) {
+  const raw = await readFile(refPath, "utf8").catch(() => void 0);
+  const count = raw === void 0 ? 0 : Number.parseInt(raw, 10);
+  return Number.isFinite(count) && count > 0 ? count : 0;
+}
+async function ensureRuntimeDependencyLink(projectRoot) {
+  return await withRuntimeDependencyLock(projectRoot, async () => {
+    const runtimeRoot = join(projectRoot, CLI_RUNTIME_ROOT);
+    const packageRoot = await resolvePackageRootFromSpecifier("@holo-js/db");
+    const nodeModulesDir = join(runtimeRoot, "node_modules");
+    const namespaceDir = join(nodeModulesDir, "@holo-js");
+    const targetPath = join(namespaceDir, "db");
+    const refPath = join(nodeModulesDir, ".holo-js-runtime-refs");
+    const references = await readRuntimeDependencyReferenceCount(refPath);
+    await mkdir(namespaceDir, { recursive: true });
+    if (references === 0) {
+      await rm(targetPath, { recursive: true, force: true });
+      await symlink(packageRoot, targetPath, "junction");
+    }
+    await writeFile(refPath, String(references + 1), "utf8");
+    return runtimeRoot;
+  });
+}
+async function cleanupRuntimeDependencyLink(projectRoot) {
+  await withRuntimeDependencyLock(projectRoot, async () => {
+    const nodeModulesDir = join(projectRoot, CLI_RUNTIME_ROOT, "node_modules");
+    const refPath = join(nodeModulesDir, ".holo-js-runtime-refs");
+    const references = await readRuntimeDependencyReferenceCount(refPath);
+    const nextReferences = references - 1;
+    if (nextReferences <= 0) {
+      await rm(nodeModulesDir, { recursive: true, force: true });
+      return;
+    }
+    await writeFile(refPath, String(nextReferences), "utf8");
+  });
+}
+function resolveRuntimeWorkerPath() {
+  const runtimePath = fileURLToPath(import.meta.url);
+  return runtimePath.endsWith("/src/runtime.ts") ? resolve(dirname(runtimePath), "runtime-worker.ts") : resolve(dirname(runtimePath), "runtime-worker.mjs");
+}
+function supportsNodeTypeStripping(version = process.versions.node) {
+  const [major = "0", minor = "0"] = version.split(".");
+  const majorVersion = Number.parseInt(major, 10);
+  const minorVersion = Number.parseInt(minor, 10);
+  return majorVersion > 22 || majorVersion === 22 && minorVersion >= 6;
+}
+function resolveCompiledRuntimeWorkerPath(workerPath) {
+  return resolve(dirname(workerPath), "../dist/runtime-worker.mjs");
+}
+function createRuntimeInvocation(workerPath = resolveRuntimeWorkerPath()) {
+  if (workerPath.endsWith(".ts")) {
+    return {
+      command: "node",
+      args: supportsNodeTypeStripping() ? ["--experimental-strip-types", workerPath] : [resolveCompiledRuntimeWorkerPath(workerPath)]
+    };
+  }
+  return {
+    command: "node",
+    args: [workerPath]
+  };
+}
+function runRuntimeInvocation(command, args, options) {
+  return new Promise((resolveInvocation) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let error = null;
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (spawnError) => {
+      error = spawnError;
+    });
+    child.on("close", (status) => {
+      resolveInvocation({
+        status,
+        error,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+function getRuntimeFailureMessage(kind, result) {
+  const stderr = result.stderr?.trim();
+  if (stderr) {
+    return formatRuntimeFailureText(stderr);
+  }
+  const stdout = result.stdout?.trim();
+  if (stdout) {
+    return formatRuntimeFailureText(stdout);
+  }
+  const errorCode = result.error && "code" in result.error ? result.error.code : void 0;
+  if (typeof errorCode === "string" && errorCode.length > 0) {
+    return `Failed to launch runtime command "${kind}": ${errorCode}.`;
+  }
+  return `Runtime command "${kind}" failed.`;
+}
+function stripRuntimeErrorPrefix(line) {
+  return line.replace(/^(?:[A-Za-z][\w.]*Error|Error):\s+/, "");
+}
+function isRuntimeErrorSourceLine(line) {
+  return line.startsWith("throw ") || line.startsWith("at ") || line === "^" || /^\^+$/.test(line);
+}
+function formatRuntimeFailureText(text) {
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const friendlyLine = lines.find((line) => line.includes("Unable to ") && !isRuntimeErrorSourceLine(line));
+  if (friendlyLine) {
+    return stripRuntimeErrorPrefix(friendlyLine);
+  }
+  const errorLine = lines.find((line) => /^(?:[A-Za-z][\w.]*Error|Error):\s+/.test(line));
+  if (errorLine) {
+    return stripRuntimeErrorPrefix(errorLine);
+  }
+  return lines[0] ?? text.trim();
+}
+async function withRuntimeEnvironment(projectRoot, kind, options, callback) {
+  if (kind === "seed") {
+    const project = await loadProjectConfig(projectRoot, { required: true });
+    await prepareProjectDiscovery(projectRoot, project.config);
+  }
+  const environment = await getRuntimeEnvironment(projectRoot);
+  let dependencyLinkEnsured = false;
+  try {
+    const envRuntimeConfig = createEnvRuntimeConfig();
+    const runtimeDatabaseConfig = mergeRuntimeDatabaseConfig(
+      environment.project.config.database,
+      envRuntimeConfig
+    );
+    const runtimeRoot = await ensureRuntimeDependencyLink(projectRoot);
+    dependencyLinkEnsured = true;
+    const runtimePayload = JSON.stringify({
+      kind,
+      projectRoot,
+      runtimeConfig: {
+        db: runtimeDatabaseConfig
+      },
+      models: environment.bundledModels.map((entry) => pathToFileURL(entry).href),
+      migrations: environment.bundledMigrations.map((entry) => pathToFileURL(entry).href),
+      seeders: environment.bundledSeeders.map((entry) => pathToFileURL(entry).href),
+      generatedSchema: environment.bundledGeneratedSchema ? pathToFileURL(environment.bundledGeneratedSchema).href : void 0,
+      generatedSchemaOutputPath: resolveGeneratedSchemaPath(projectRoot, environment.project.config),
+      generatedSchemaRuntimeOutputPath: resolve(projectRoot, GENERATED_SCHEMA_RUNTIME_PATH),
+      options
+    });
+    const runtime = createRuntimeInvocation();
+    const result = await runRuntimeInvocation(runtime.command, runtime.args, {
+      cwd: runtimeRoot,
+      env: {
+        ...process.env,
+        HOLO_RUNTIME_PAYLOAD: runtimePayload
+      }
+    });
+    if (result.status !== 0) {
+      throw new Error(getRuntimeFailureMessage(kind, result));
+    }
+    return await callback((result.stdout ?? "").trim());
+  } finally {
+    if (dependencyLinkEnsured) {
+      await cleanupRuntimeDependencyLink(projectRoot);
+    }
+    await environment.cleanup();
+  }
+}
+
+export {
+  resolveConfigModuleUrl,
+  initializeProjectRuntime,
+  parseBooleanEnv,
+  cacheProjectConfig,
+  createEnvRuntimeConfig,
+  normalizeRuntimeConnectionInput,
+  isDefined,
+  filterDefinedRuntimeConnectionInput,
+  mergeRuntimeDatabaseConfig,
+  RUNTIME_MIGRATION_NAME_PATTERN,
+  inferRuntimeMigrationName,
+  normalizeRuntimeMigration,
+  compileFreshDropIdentifierPath,
+  dropAllTablesForFresh,
+  getRuntimeEnvironment,
+  resolvePackageRootFromSpecifier,
+  ensureRuntimeDependencyLink,
+  cleanupRuntimeDependencyLink,
+  resolveRuntimeWorkerPath,
+  createRuntimeInvocation,
+  runRuntimeInvocation,
+  getRuntimeFailureMessage,
+  withRuntimeEnvironment
+};

package/dist/chunk-LHK5YUR4.mjs

@@ -0,0 +1,156 @@
+import {
+  HOLO_PACKAGE_VERSION,
+  readTextFile,
+  writeTextFile
+} from "./chunk-YACY2572.mjs";
+
+// src/package-json.ts
+import { join } from "path";
+function normalizeDependencyMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([, dependencyVersion]) => typeof dependencyVersion === "string").sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function isWorkspaceDependencyVersion(value) {
+  return typeof value === "string" && value.startsWith("workspace:");
+}
+function assertValidDependencyName(packageName) {
+  if (!/^@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/.test(packageName) && !/^[a-z0-9][a-z0-9._-]*$/.test(packageName)) {
+    throw new Error(`Invalid dependency package name: ${packageName || "(empty)"}.`);
+  }
+}
+function resolveInstalledPackageJsonPath(projectRoot, packageName) {
+  return join(projectRoot, "node_modules", ...packageName.split("/"), "package.json");
+}
+async function resolveInstalledPackageVersion(projectRoot, packageName) {
+  const packageJson = await readTextFile(resolveInstalledPackageJsonPath(projectRoot, packageName));
+  if (!packageJson) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(packageJson);
+    return typeof parsed.version === "string" && parsed.version.trim() ? `^${parsed.version.trim()}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolvePackageVersion(projectRoot, packageName, dependencies, devDependencies) {
+  const currentPackageVersion = dependencies[packageName] ?? devDependencies[packageName];
+  if (typeof currentPackageVersion === "string") {
+    return currentPackageVersion;
+  }
+  const workspaceVersion = Object.entries({
+    ...dependencies,
+    ...devDependencies
+  }).find(([dependencyName, dependencyVersion]) => dependencyName.startsWith("@holo-js/") && isWorkspaceDependencyVersion(dependencyVersion))?.[1];
+  if (packageName.startsWith("@holo-js/")) {
+    return workspaceVersion ?? `^${HOLO_PACKAGE_VERSION}`;
+  }
+  return await resolveInstalledPackageVersion(projectRoot, packageName) ?? "latest";
+}
+function sortDependencyMap(dependencies) {
+  return Object.fromEntries(
+    Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+async function readPackageJsonDependencyState(projectRoot) {
+  const packageJsonPath = join(projectRoot, "package.json");
+  const packageJson = await readTextFile(packageJsonPath);
+  if (!packageJson) {
+    throw new Error(`Missing package.json in ${projectRoot}.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(packageJson);
+  } catch {
+    throw new Error(`Invalid package.json in ${projectRoot}.`);
+  }
+  return {
+    packageJsonPath,
+    parsed,
+    dependencies: normalizeDependencyMap(parsed.dependencies),
+    devDependencies: normalizeDependencyMap(parsed.devDependencies)
+  };
+}
+async function writePackageJsonDependencyState(state) {
+  state.parsed.dependencies = sortDependencyMap(state.dependencies);
+  if (Object.keys(state.devDependencies).length > 0) {
+    state.parsed.devDependencies = sortDependencyMap(state.devDependencies);
+  } else {
+    delete state.parsed.devDependencies;
+  }
+  await writeTextFile(state.packageJsonPath, `${JSON.stringify(state.parsed, null, 2)}
+`);
+}
+async function hasProjectDependency(projectRoot, packageName) {
+  const packageJson = await readTextFile(join(projectRoot, "package.json"));
+  if (!packageJson) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(packageJson);
+    return typeof parsed.dependencies?.[packageName] === "string" || typeof parsed.devDependencies?.[packageName] === "string";
+  } catch {
+    return false;
+  }
+}
+async function upsertProjectDependency(projectRoot, packageName) {
+  assertValidDependencyName(packageName);
+  const state = await readPackageJsonDependencyState(projectRoot);
+  const nextVersion = await resolvePackageVersion(projectRoot, packageName, state.dependencies, state.devDependencies);
+  if (state.dependencies[packageName] === nextVersion && typeof state.devDependencies[packageName] === "undefined") {
+    return false;
+  }
+  state.dependencies[packageName] = nextVersion;
+  delete state.devDependencies[packageName];
+  await writePackageJsonDependencyState(state);
+  return true;
+}
+async function pinProjectDependencyVersions(projectRoot, packageNames) {
+  const state = await readPackageJsonDependencyState(projectRoot);
+  let changed = false;
+  for (const packageName of packageNames) {
+    assertValidDependencyName(packageName);
+    if (packageName.startsWith("@holo-js/")) {
+      continue;
+    }
+    const installedVersion = await resolveInstalledPackageVersion(projectRoot, packageName);
+    if (!installedVersion) {
+      continue;
+    }
+    if (state.dependencies[packageName] === "latest") {
+      state.dependencies[packageName] = installedVersion;
+      changed = true;
+    }
+    if (state.devDependencies[packageName] === "latest") {
+      state.devDependencies[packageName] = installedVersion;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return false;
+  }
+  await writePackageJsonDependencyState(state);
+  return true;
+}
+async function removeProjectDependency(projectRoot, packageName) {
+  assertValidDependencyName(packageName);
+  const state = await readPackageJsonDependencyState(projectRoot);
+  if (typeof state.dependencies[packageName] === "undefined" && typeof state.devDependencies[packageName] === "undefined") {
+    return false;
+  }
+  delete state.dependencies[packageName];
+  delete state.devDependencies[packageName];
+  await writePackageJsonDependencyState(state);
+  return true;
+}
+
+export {
+  hasProjectDependency,
+  upsertProjectDependency,
+  pinProjectDependencyVersions,
+  removeProjectDependency
+};

package/dist/{chunk-LBJAJLKU.mjs → chunk-M3IPUCTM.mjs}

@@ -1,6 +1,6 @@
 import {
   readTextFile
-} from "./chunk-ILU426CF.mjs";
+} from "./chunk-YACY2572.mjs";
 
 // src/fs-utils.ts
 import { stat } from "fs/promises";