@holo-js/cli 0.1.4 → 0.1.5

package/dist/chunk-G5ADO27Q.mjs

@@ -1,463 +0,0 @@
-// src/project/runtime.ts
-import { mkdtemp, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { createRequire } from "module";
-import { basename, dirname, extname as extname2, join as join2, resolve as resolve2 } from "path";
-import { pathToFileURL } from "url";
-import { build } from "esbuild";
-
-// src/project/shared.ts
-import { stat } from "fs/promises";
-import { extname, join, relative, resolve } from "path";
-var SUPPORTED_AUTH_SOCIAL_PROVIDERS = [
-  "google",
-  "github",
-  "discord",
-  "facebook",
-  "apple",
-  "linkedin"
-];
-var AUTH_SOCIAL_PROVIDER_PACKAGE_NAMES = {
-  google: "@holo-js/auth-social-google",
-  github: "@holo-js/auth-social-github",
-  discord: "@holo-js/auth-social-discord",
-  facebook: "@holo-js/auth-social-facebook",
-  apple: "@holo-js/auth-social-apple",
-  linkedin: "@holo-js/auth-social-linkedin"
-};
-var APP_CONFIG_FILE_NAMES = [
-  "config/app.ts",
-  "config/app.mts",
-  "config/app.js",
-  "config/app.mjs"
-];
-var DATABASE_CONFIG_FILE_NAMES = [
-  "config/database.ts",
-  "config/database.mts",
-  "config/database.js",
-  "config/database.mjs"
-];
-var AUTH_CONFIG_FILE_NAMES = [
-  "config/auth.ts",
-  "config/auth.mts",
-  "config/auth.js",
-  "config/auth.mjs",
-  "config/auth.cts",
-  "config/auth.cjs"
-];
-var SESSION_CONFIG_FILE_NAMES = [
-  "config/session.ts",
-  "config/session.mts",
-  "config/session.js",
-  "config/session.mjs",
-  "config/session.cts",
-  "config/session.cjs"
-];
-var QUEUE_CONFIG_FILE_NAMES = [
-  "config/queue.ts",
-  "config/queue.mts",
-  "config/queue.js",
-  "config/queue.mjs"
-];
-var REDIS_CONFIG_FILE_NAMES = [
-  "config/redis.ts",
-  "config/redis.mts",
-  "config/redis.js",
-  "config/redis.mjs",
-  "config/redis.cts",
-  "config/redis.cjs"
-];
-var CACHE_CONFIG_FILE_NAMES = [
-  "config/cache.ts",
-  "config/cache.mts",
-  "config/cache.js",
-  "config/cache.mjs",
-  "config/cache.cts",
-  "config/cache.cjs"
-];
-var NOTIFICATIONS_CONFIG_FILE_NAMES = [
-  "config/notifications.ts",
-  "config/notifications.mts",
-  "config/notifications.js",
-  "config/notifications.mjs",
-  "config/notifications.cts",
-  "config/notifications.cjs"
-];
-var MAIL_CONFIG_FILE_NAMES = [
-  "config/mail.ts",
-  "config/mail.mts",
-  "config/mail.js",
-  "config/mail.mjs",
-  "config/mail.cts",
-  "config/mail.cjs"
-];
-var SECURITY_CONFIG_FILE_NAMES = [
-  "config/security.ts",
-  "config/security.mts",
-  "config/security.js",
-  "config/security.mjs",
-  "config/security.cts",
-  "config/security.cjs"
-];
-var BROADCAST_CONFIG_FILE_NAMES = [
-  "config/broadcast.ts",
-  "config/broadcast.mts",
-  "config/broadcast.js",
-  "config/broadcast.mjs",
-  "config/broadcast.cts",
-  "config/broadcast.cjs"
-];
-var DB_DRIVER_PACKAGE_NAMES = {
-  sqlite: "@holo-js/db-sqlite",
-  postgres: "@holo-js/db-postgres",
-  mysql: "@holo-js/db-mysql"
-};
-var COMMAND_FILE_PATTERN = /\.(?:[cm]?ts|[cm]?js)$/;
-var MIGRATION_NAME_PATTERN = /^\d{4}_\d{2}_\d{2}_\d{6}_[a-z0-9_]+$/;
-var HOLO_RUNTIME_ROOT = join(".holo-js", "runtime");
-var CLI_RUNTIME_ROOT = join(HOLO_RUNTIME_ROOT, "cli");
-var GENERATED_ROOT = join(".holo-js", "generated");
-var GENERATED_INDEX_PATH = join(GENERATED_ROOT, "index.ts");
-var GENERATED_METADATA_PATH = join(GENERATED_ROOT, "metadata.ts");
-var GENERATED_MODELS_PATH = join(GENERATED_ROOT, "models.ts");
-var GENERATED_MIGRATIONS_PATH = join(GENERATED_ROOT, "migrations.ts");
-var GENERATED_SEEDERS_PATH = join(GENERATED_ROOT, "seeders.ts");
-var GENERATED_COMMANDS_PATH = join(GENERATED_ROOT, "commands.ts");
-var GENERATED_JOBS_PATH = join(GENERATED_ROOT, "jobs.ts");
-var GENERATED_EVENTS_PATH = join(GENERATED_ROOT, "events.ts");
-var GENERATED_LISTENERS_PATH = join(GENERATED_ROOT, "listeners.ts");
-var GENERATED_BROADCAST_PATH = join(GENERATED_ROOT, "broadcast.ts");
-var GENERATED_CHANNELS_PATH = join(GENERATED_ROOT, "channels.ts");
-var GENERATED_BROADCAST_MANIFEST_PATH = join(GENERATED_ROOT, "broadcast-manifest.ts");
-var GENERATED_AUTHORIZATION_ROOT = join(GENERATED_ROOT, "authorization");
-var GENERATED_AUTHORIZATION_REGISTRY_PATH = join(GENERATED_AUTHORIZATION_ROOT, "registry.ts");
-var GENERATED_AUTHORIZATION_TYPES_PATH = join(GENERATED_AUTHORIZATION_ROOT, "types.d.ts");
-var GENERATED_CONFIG_TYPES_PATH = join(GENERATED_ROOT, "config.d.ts");
-var GENERATED_QUEUE_TYPES_PATH = join(GENERATED_ROOT, "queue.d.ts");
-var GENERATED_EVENT_TYPES_PATH = join(GENERATED_ROOT, "events.d.ts");
-var GENERATED_BROADCAST_TYPES_PATH = join(GENERATED_ROOT, "broadcast.d.ts");
-var GENERATED_REGISTRY_JSON_PATH = join(GENERATED_ROOT, "registry.json");
-var GENERATED_TSCONFIG_PATH = join(GENERATED_ROOT, "tsconfig.json");
-var GENERATED_GITIGNORE_PATH = join(GENERATED_ROOT, ".gitignore");
-var CONFIG_EXTENSION_PRIORITY = [".ts", ".mts", ".js", ".mjs", ".cts", ".cjs"];
-var SUPPORTED_CONFIG_EXTENSIONS = new Set(CONFIG_EXTENSION_PRIORITY);
-var SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES = ["storage", "events", "queue", "validation", "forms", "auth", "authorization", "notifications", "mail", "broadcast", "security", "cache"];
-var SUPPORTED_QUEUE_INSTALLER_DRIVERS = ["sync", "redis", "database"];
-var SUPPORTED_CACHE_INSTALLER_DRIVERS = ["file", "redis", "database"];
-var HOLO_EVENT_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.events.definition");
-var HOLO_LISTENER_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.events.listener");
-function toPosixPath(value) {
-  return value.replace(/\\/g, "/");
-}
-function hasEventDefinitionMarker(value) {
-  return value !== null && typeof value === "object" && HOLO_EVENT_DEFINITION_MARKER in value;
-}
-function hasListenerDefinitionMarker(value) {
-  return value !== null && typeof value === "object" && HOLO_LISTENER_DEFINITION_MARKER in value;
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-async function pathExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isSupportedScaffoldOptionalPackage(value) {
-  return SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES.includes(value);
-}
-function normalizeScaffoldOptionalPackageName(value) {
-  const current = value.trim().toLowerCase();
-  if (current === "validate") {
-    return "validation";
-  }
-  if (current === "form") {
-    return "forms";
-  }
-  return current;
-}
-function normalizeScaffoldOptionalPackages(value) {
-  if (!value || value.length === 0) {
-    return [];
-  }
-  const normalized = /* @__PURE__ */ new Set();
-  for (const entry of value) {
-    const current = normalizeScaffoldOptionalPackageName(entry);
-    if (!isSupportedScaffoldOptionalPackage(current)) {
-      throw new Error(
-        `Unsupported optional package: ${entry}. Expected one of ${SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES.join(", ")}.`
-      );
-    }
-    normalized.add(current);
-    if (current === "forms") {
-      normalized.add("validation");
-    }
-  }
-  return [...normalized].sort((left, right) => left.localeCompare(right));
-}
-function isSupportedQueueInstallerDriver(value) {
-  return SUPPORTED_QUEUE_INSTALLER_DRIVERS.includes(value);
-}
-function isSupportedCacheInstallerDriver(value) {
-  return SUPPORTED_CACHE_INSTALLER_DRIVERS.includes(value);
-}
-function sanitizePackageName(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function makeProjectRelativePath(projectRoot, absolutePath) {
-  return toPosixPath(relative(projectRoot, absolutePath));
-}
-function resolveDefaultArtifactPath(projectRoot, relativeDir, fileName) {
-  return resolve(projectRoot, relativeDir, fileName);
-}
-
-// src/project/runtime.ts
-var projectModuleBundler = build;
-function resolveWorkspacePackageImportSpecifier(specifier) {
-  if (!specifier.startsWith("@holo-js/")) {
-    return void 0;
-  }
-  const [, packageName, ...subpathSegments] = specifier.split("/");
-  if (!packageName) {
-    return void 0;
-  }
-  const subpath = subpathSegments.join("/");
-  const candidateRoots = [
-    resolve2(import.meta.dirname, "../../", packageName),
-    resolve2(import.meta.dirname, "../../../", packageName)
-  ];
-  for (const candidateRoot of candidateRoots) {
-    const candidatePath = join2(candidateRoot, "dist", subpath ? `${subpath}.mjs` : "index.mjs");
-    if (existsSync(candidatePath)) {
-      return pathToFileURL(candidatePath).href;
-    }
-  }
-  return void 0;
-}
-function resolveProjectPackageImportSpecifier(projectRoot, specifier, resolveSpecifier) {
-  try {
-    const projectRequire = createRequire(join2(projectRoot, "package.json"));
-    const resolved = (resolveSpecifier ?? projectRequire.resolve.bind(projectRequire))(specifier);
-    return pathToFileURL(resolved).href;
-  } catch {
-    return resolveWorkspacePackageImportSpecifier(specifier) ?? specifier;
-  }
-}
-async function loadQueueDiscoveryModule(projectRoot) {
-  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/queue"));
-}
-async function loadEventsDiscoveryModule(projectRoot) {
-  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/events"));
-}
-async function loadBroadcastDiscoveryModule(projectRoot) {
-  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/broadcast"));
-}
-async function loadAuthorizationDiscoveryModule(projectRoot) {
-  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/authorization"));
-}
-async function resolveFirstExistingPath(projectRoot, fileNames) {
-  for (const fileName of fileNames) {
-    const candidate = join2(projectRoot, fileName);
-    if (await pathExists(candidate)) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-async function isModulePackage(projectRoot) {
-  const packageJsonPath = join2(projectRoot, "package.json");
-  if (!await pathExists(packageJsonPath)) {
-    return false;
-  }
-  try {
-    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    return packageJson.type === "module";
-  } catch {
-    return false;
-  }
-}
-function getProjectTsconfigPath(projectRoot) {
-  return join2(projectRoot, "tsconfig.json");
-}
-async function writeLoaderTsconfig(projectRoot, tempDir) {
-  const projectTsconfigPath = getProjectTsconfigPath(projectRoot);
-  if (await pathExists(projectTsconfigPath)) {
-    return projectTsconfigPath;
-  }
-  const tsconfigPath = join2(tempDir, "tsconfig.json");
-  const contents = JSON.stringify({
-    compilerOptions: {
-      baseUrl: projectRoot,
-      paths: {
-        "~/*": ["./*"],
-        "@/*": ["./*"]
-      }
-    }
-  }, null, 2);
-  await writeFile(tsconfigPath, `${contents}
-`, "utf8");
-  return tsconfigPath;
-}
-async function bundleProjectModule(projectRoot, entryPath, options = {}) {
-  const runtimeTempRoot = join2(projectRoot, CLI_RUNTIME_ROOT);
-  await mkdir(runtimeTempRoot, { recursive: true });
-  const tempDir = await mkdtemp(join2(runtimeTempRoot, "bundle-"));
-  const tsconfigPath = await writeLoaderTsconfig(projectRoot, tempDir);
-  const outdir = join2(tempDir, "out");
-  const outfile = join2(outdir, `${basename(entryPath, extname2(entryPath))}.mjs`);
-  const cleanup = async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  };
-  try {
-    await projectModuleBundler({
-      absWorkingDir: projectRoot,
-      bundle: true,
-      entryPoints: [entryPath],
-      outfile,
-      format: "esm",
-      logLevel: "silent",
-      packages: "external",
-      platform: "node",
-      target: "node20",
-      tsconfig: tsconfigPath,
-      sourcemap: false,
-      external: [...options.external ?? []]
-    });
-    return {
-      path: outfile,
-      cleanup
-    };
-  } catch (error) {
-    await cleanup();
-    if (error && typeof error === "object" && Array.isArray(error.errors)) {
-      const message = error.errors.map((entry) => {
-        if (typeof entry.text === "string" && entry.text.trim()) {
-          return entry.text;
-        }
-        if (typeof entry.message === "string" && entry.message.trim()) {
-          return entry.message;
-        }
-        return "Unknown build error.";
-      }).join("\n");
-      throw new Error(message);
-    }
-    if (error instanceof Error && error.message) {
-      throw error;
-    }
-    throw new Error(`Failed to load ${entryPath}.`);
-  }
-}
-async function importProjectModule(projectRoot, entryPath) {
-  const bundled = await bundleProjectModule(projectRoot, entryPath);
-  try {
-    return await import(`${pathToFileURL(bundled.path).href}?t=${Date.now()}`);
-  } finally {
-    await bundled.cleanup();
-  }
-}
-async function findProjectRoot(startDir) {
-  let current = resolve2(startDir);
-  let fallbackRoot;
-  while (true) {
-    if (await resolveFirstExistingPath(current, APP_CONFIG_FILE_NAMES)) {
-      return current;
-    }
-    if (!fallbackRoot && (await pathExists(join2(current, "package.json")) || await pathExists(join2(current, "nuxt.config.ts")) || await pathExists(join2(current, "nuxt.config.js")) || await pathExists(join2(current, "bun.lock")))) {
-      fallbackRoot = current;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      return fallbackRoot ?? resolve2(startDir);
-    }
-    current = parent;
-  }
-}
-async function readTextFile(path) {
-  if (!await pathExists(path)) {
-    return void 0;
-  }
-  return readFile(path, "utf8");
-}
-async function writeTextFile(path, contents) {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, contents, "utf8");
-}
-function resetProjectModuleBundlerForTesting() {
-  projectModuleBundler = build;
-}
-function setProjectModuleBundlerForTesting(bundler) {
-  projectModuleBundler = bundler;
-}
-
-export {
-  SUPPORTED_AUTH_SOCIAL_PROVIDERS,
-  AUTH_SOCIAL_PROVIDER_PACKAGE_NAMES,
-  APP_CONFIG_FILE_NAMES,
-  DATABASE_CONFIG_FILE_NAMES,
-  AUTH_CONFIG_FILE_NAMES,
-  SESSION_CONFIG_FILE_NAMES,
-  QUEUE_CONFIG_FILE_NAMES,
-  REDIS_CONFIG_FILE_NAMES,
-  CACHE_CONFIG_FILE_NAMES,
-  NOTIFICATIONS_CONFIG_FILE_NAMES,
-  MAIL_CONFIG_FILE_NAMES,
-  SECURITY_CONFIG_FILE_NAMES,
-  BROADCAST_CONFIG_FILE_NAMES,
-  DB_DRIVER_PACKAGE_NAMES,
-  COMMAND_FILE_PATTERN,
-  MIGRATION_NAME_PATTERN,
-  HOLO_RUNTIME_ROOT,
-  CLI_RUNTIME_ROOT,
-  GENERATED_ROOT,
-  GENERATED_INDEX_PATH,
-  GENERATED_METADATA_PATH,
-  GENERATED_MODELS_PATH,
-  GENERATED_MIGRATIONS_PATH,
-  GENERATED_SEEDERS_PATH,
-  GENERATED_COMMANDS_PATH,
-  GENERATED_JOBS_PATH,
-  GENERATED_EVENTS_PATH,
-  GENERATED_LISTENERS_PATH,
-  GENERATED_BROADCAST_PATH,
-  GENERATED_CHANNELS_PATH,
-  GENERATED_BROADCAST_MANIFEST_PATH,
-  GENERATED_AUTHORIZATION_REGISTRY_PATH,
-  GENERATED_AUTHORIZATION_TYPES_PATH,
-  GENERATED_CONFIG_TYPES_PATH,
-  GENERATED_QUEUE_TYPES_PATH,
-  GENERATED_EVENT_TYPES_PATH,
-  GENERATED_BROADCAST_TYPES_PATH,
-  GENERATED_REGISTRY_JSON_PATH,
-  GENERATED_TSCONFIG_PATH,
-  GENERATED_GITIGNORE_PATH,
-  CONFIG_EXTENSION_PRIORITY,
-  SUPPORTED_CONFIG_EXTENSIONS,
-  toPosixPath,
-  hasEventDefinitionMarker,
-  hasListenerDefinitionMarker,
-  isRecord,
-  pathExists,
-  normalizeScaffoldOptionalPackages,
-  isSupportedQueueInstallerDriver,
-  isSupportedCacheInstallerDriver,
-  sanitizePackageName,
-  makeProjectRelativePath,
-  resolveDefaultArtifactPath,
-  resolveProjectPackageImportSpecifier,
-  loadQueueDiscoveryModule,
-  loadEventsDiscoveryModule,
-  loadBroadcastDiscoveryModule,
-  loadAuthorizationDiscoveryModule,
-  resolveFirstExistingPath,
-  isModulePackage,
-  bundleProjectModule,
-  importProjectModule,
-  findProjectRoot,
-  readTextFile,
-  writeTextFile,
-  resetProjectModuleBundlerForTesting,
-  setProjectModuleBundlerForTesting
-};

package/dist/chunk-GSQ3HTRO.mjs

@@ -1,165 +0,0 @@
-import {
-  loadGeneratedProjectRegistry
-} from "./chunk-H7TJ4FB3.mjs";
-import {
-  APP_CONFIG_FILE_NAMES,
-  DATABASE_CONFIG_FILE_NAMES,
-  isModulePackage,
-  pathExists,
-  resolveFirstExistingPath
-} from "./chunk-G5ADO27Q.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
-};