@holo-js/cli 0.1.4 → 0.1.6

package/dist/chunk-5BLEC66P.mjs

@@ -0,0 +1,284 @@
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-MXKNQACM.mjs";
+import {
+  APP_CONFIG_FILE_NAMES,
+  DATABASE_CONFIG_FILE_NAMES,
+  bundleProjectModule,
+  isModulePackage,
+  pathExists,
+  resolveFirstExistingPath
+} from "./chunk-R6BWRY3E.mjs";
+
+// src/project/config.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, extname, join, resolve } from "path";
+import { pathToFileURL } from "url";
+import {
+  loadConfigDirectory,
+  holoAppDefaults,
+  holoDatabaseDefaults,
+  loadEnvironment,
+  normalizeAppConfig,
+  normalizeDatabaseConfig
+} from "@holo-js/config";
+import {
+  DEFAULT_HOLO_PROJECT_PATHS,
+  normalizeHoloProjectConfig,
+  renderGeneratedSchemaPlaceholder
+} from "@holo-js/db";
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolveConfigExport(moduleValue) {
+  if (isObject(moduleValue) && isObject(moduleValue.default)) {
+    return moduleValue.default;
+  }
+  if (isObject(moduleValue) && isObject(moduleValue.config)) {
+    return moduleValue.config;
+  }
+  if (isObject(moduleValue) && ("default" in moduleValue || "config" in moduleValue)) {
+    return {};
+  }
+  if (isObject(moduleValue)) {
+    return moduleValue;
+  }
+  return {};
+}
+var projectConfigImportStates = /* @__PURE__ */ new Map();
+var projectConfigImportLock = Promise.resolve();
+var projectConfigImportNonce = 0;
+async function withProjectConfigImportLock(callback) {
+  const previousLock = projectConfigImportLock;
+  let releaseLock = () => {
+  };
+  projectConfigImportLock = new Promise((resolveLock) => {
+    releaseLock = resolveLock;
+  });
+  await previousLock;
+  try {
+    return await callback();
+  } finally {
+    releaseLock();
+  }
+}
+function hashProjectConfigImportInputs(fileContents, environmentValues) {
+  const hash = createHash("sha256").update(fileContents).update("\0");
+  const keys = Object.keys(environmentValues).sort();
+  for (const key of keys) {
+    hash.update(key).update("\0").update(environmentValues[key] ?? "").update("\0");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+async function resolveProjectConfigImportUrl(filePath, environmentValues) {
+  const fileUrl = pathToFileURL(filePath).href;
+  const hash = hashProjectConfigImportInputs(await readFile(filePath, "utf8"), environmentValues);
+  const previous = projectConfigImportStates.get(filePath);
+  if (previous?.hash === hash) {
+    return `${fileUrl}?t=${previous.nonce}`;
+  }
+  projectConfigImportNonce += 1;
+  const next = {
+    hash,
+    nonce: projectConfigImportNonce
+  };
+  projectConfigImportStates.set(filePath, next);
+  return `${fileUrl}?t=${next.nonce}`;
+}
+async function importProjectConfigFile(projectRoot, filePath, environmentValues) {
+  return withProjectConfigImportLock(async () => {
+    const previousEnvEntries = /* @__PURE__ */ new Map();
+    const importUrl = await resolveProjectConfigImportUrl(filePath, environmentValues);
+    const configExtension = extname(filePath);
+    const bundled = configExtension === ".ts" || configExtension === ".mts" ? await bundleProjectModule(projectRoot, filePath) : void 0;
+    const resolvedImportUrl = bundled ? `${pathToFileURL(bundled.path).href}${new URL(importUrl).search}` : importUrl;
+    try {
+      for (const [key, value] of Object.entries(environmentValues)) {
+        previousEnvEntries.set(key, process.env[key]);
+        process.env[key] = value;
+      }
+      return resolveConfigExport(await import(resolvedImportUrl));
+    } finally {
+      for (const [key, value] of previousEnvEntries) {
+        if (typeof value === "string") {
+          process.env[key] = value;
+          continue;
+        }
+        Reflect.deleteProperty(process.env, key);
+      }
+      await bundled?.cleanup();
+    }
+  });
+}
+async function loadCachedProjectSourceConfig(projectRoot, environmentName) {
+  const cachePath = join(projectRoot, ".holo-js/generated/config-cache.json");
+  if (environmentName !== "production" || !await pathExists(cachePath)) {
+    return void 0;
+  }
+  const loaded = await loadConfigDirectory(projectRoot, {
+    processEnv: process.env
+  });
+  return {
+    app: loaded.app,
+    database: loaded.database
+  };
+}
+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 databaseConfigPath = await resolveFirstExistingPath(projectRoot, DATABASE_CONFIG_FILE_NAMES);
+  const environment = await loadEnvironment({
+    cwd: projectRoot,
+    processEnv: process.env
+  });
+  const cachedConfig = await loadCachedProjectSourceConfig(projectRoot, environment.name);
+  const app = cachedConfig?.app ?? normalizeAppConfig(await importProjectConfigFile(projectRoot, appConfigPath, environment.values));
+  const database = cachedConfig?.database ?? normalizeDatabaseConfig(databaseConfigPath ? await importProjectConfigFile(projectRoot, databaseConfigPath, environment.values) : void 0);
+  const baseConfig = normalizeHoloProjectConfig({
+    paths: app.paths,
+    models: app.models,
+    migrations: app.migrations,
+    seeders: app.seeders,
+    database
+  });
+  const registry = await loadGeneratedProjectRegistry(projectRoot);
+  return {
+    manifestPath: appConfigPath,
+    config: registry ? normalizeHoloProjectConfig({
+      paths: baseConfig.paths,
+      models: [.../* @__PURE__ */ new Set([
+        ...baseConfig.models,
+        ...registry.models.map((entry) => entry.sourcePath)
+      ])],
+      migrations: [.../* @__PURE__ */ new Set([
+        ...baseConfig.migrations,
+        ...registry.migrations.map((entry) => entry.sourcePath)
+      ])],
+      seeders: [.../* @__PURE__ */ new Set([
+        ...baseConfig.seeders,
+        ...registry.seeders.map((entry) => entry.sourcePath)
+      ])],
+      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
+};

package/dist/{chunk-JX2ZH6XY.mjs → chunk-5EU32E7X.mjs}

@@ -2,10 +2,10 @@
 import { createInterface } from "readline/promises";
 var SUPPORTED_NEW_FRAMEWORKS = ["nuxt", "next", "sveltekit"];
 var SUPPORTED_NEW_DATABASE_DRIVERS = ["sqlite", "mysql", "postgres"];
-var SUPPORTED_NEW_PACKAGE_MANAGERS = ["bun", "npm", "pnpm", "yarn"];
+var SUPPORTED_NEW_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 var SUPPORTED_NEW_STORAGE_DISKS = ["local", "public"];
 var SUPPORTED_NEW_OPTIONAL_PACKAGES = ["storage", "events", "queue", "validation", "forms", "auth", "authorization", "notifications", "mail", "broadcast", "security", "cache"];
-var SUPPORTED_INSTALL_TARGETS = ["queue", "events", "auth", "authorization", "notifications", "mail", "broadcast", "security", "cache"];
+var SUPPORTED_INSTALL_TARGETS = ["queue", "events", "auth", "authorization", "notifications", "mail", "broadcast", "security", "cache", "media"];
 var SUPPORTED_QUEUE_INSTALL_DRIVERS = ["sync", "redis", "database"];
 var SUPPORTED_CACHE_INSTALL_DRIVERS = ["file", "redis", "database"];
 function parseTokens(tokens) {
@@ -161,7 +161,7 @@ async function resolveNewProjectInput(io, input, prompts = {
   }
   const framework = resolveStringFlag(input.flags, "framework") ? normalizeChoice(resolveStringFlag(input.flags, "framework"), SUPPORTED_NEW_FRAMEWORKS, "framework") : interactive ? await prompts.choose("Framework", SUPPORTED_NEW_FRAMEWORKS, "nuxt") : "nuxt";
   const databaseDriver = resolveStringFlag(input.flags, "database") ? normalizeChoice(resolveStringFlag(input.flags, "database"), SUPPORTED_NEW_DATABASE_DRIVERS, "database driver") : interactive ? await prompts.choose("Database driver", SUPPORTED_NEW_DATABASE_DRIVERS, "sqlite") : "sqlite";
-  const packageManager = resolveStringFlag(input.flags, "package-manager") ? normalizeChoice(resolveStringFlag(input.flags, "package-manager"), SUPPORTED_NEW_PACKAGE_MANAGERS, "package manager") : interactive ? await prompts.choose("Package manager", SUPPORTED_NEW_PACKAGE_MANAGERS, "bun") : "bun";
+  const packageManager = resolveStringFlag(input.flags, "package-manager") ? normalizeChoice(resolveStringFlag(input.flags, "package-manager"), SUPPORTED_NEW_PACKAGE_MANAGERS, "package manager") : interactive ? await prompts.choose("Package manager", SUPPORTED_NEW_PACKAGE_MANAGERS, "npm") : "npm";
   const requestedOptionalPackages = collectMultiStringFlag(input.flags, "package");
   let optionalPackages;
   if (requestedOptionalPackages) {

package/dist/{chunk-Q5F6C2D4.mjs → chunk-BAFQ2GOA.mjs}

@@ -1,6 +1,6 @@
 import {
   fileExists
-} from "./chunk-EUIVXVJL.mjs";
+} from "./chunk-57SJ566R.mjs";
 
 // src/migrations.ts
 import { join } from "path";

package/dist/{chunk-CUL4RJTG.mjs → chunk-F4MT6GBK.mjs}

@@ -1,6 +1,6 @@
 import {
   readTextFile
-} from "./chunk-G5ADO27Q.mjs";
+} from "./chunk-R6BWRY3E.mjs";
 
 // src/package-json.ts
 import { join } from "path";