@holo-js/cli 0.3.0 → 0.3.2

package/dist/chunk-LALDNNPH.mjs

@@ -1,428 +0,0 @@
-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-M3IPUCTM.mjs

@@ -1,25 +0,0 @@
-import {
-  readTextFile
-} from "./chunk-YACY2572.mjs";
-
-// src/fs-utils.ts
-import { stat } from "fs/promises";
-async function fileExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureAbsent(path) {
-  const existing = await readTextFile(path);
-  if (typeof existing !== "undefined") {
-    throw new TypeError(`Refusing to overwrite existing file: ${path}`);
-  }
-}
-
-export {
-  fileExists,
-  ensureAbsent
-};