@holo-js/cli 0.3.0 → 0.3.2

package/dist/broadcast-AABT52BK.mjs

@@ -1,206 +0,0 @@
-import {
-  initializeProjectRuntime
-} from "./chunk-LALDNNPH.mjs";
-import "./chunk-M3IPUCTM.mjs";
-import {
-  writeLine
-} from "./chunk-I7QBCEV7.mjs";
-import "./chunk-HX6MOYBO.mjs";
-import {
-  prepareProjectDiscovery
-} from "./chunk-QSVMXMTQ.mjs";
-import "./chunk-OI54DOHK.mjs";
-import {
-  loadProjectConfig
-} from "./chunk-JVLZ3SOW.mjs";
-import {
-  loadGeneratedProjectRegistry
-} from "./chunk-R4ZYMEDU.mjs";
-import "./chunk-3RFRE7XG.mjs";
-import "./chunk-TRYHX5S4.mjs";
-import {
-  importProjectModule,
-  resolveProjectPackageImportSpecifier
-} from "./chunk-YACY2572.mjs";
-
-// src/broadcast.ts
-import { basename, extname, resolve } from "path";
-import { readFile } from "fs/promises";
-import { loadConfigDirectory } from "@holo-js/config";
-function hasLoadedRedisConfigSection(loadedFiles) {
-  return Array.isArray(loadedFiles) && loadedFiles.some((filePath) => {
-    return basename(filePath, extname(filePath)) === "redis";
-  });
-}
-async function hasProjectPackageDependency(projectRoot, packageName) {
-  try {
-    const manifest = JSON.parse(await readFile(resolve(projectRoot, "package.json"), "utf8"));
-    return Boolean(
-      manifest.dependencies?.[packageName] || manifest.devDependencies?.[packageName] || manifest.optionalDependencies?.[packageName] || manifest.peerDependencies?.[packageName]
-    );
-  } catch {
-    return false;
-  }
-}
-async function loadBroadcastCliModule(projectRoot) {
-  try {
-    return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/broadcast"));
-  } catch (error) {
-    const details = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Unable to load @holo-js/broadcast from ${projectRoot}. Install it with "holo install broadcast". ${details}`
-    );
-  }
-}
-async function loadRealtimeServerModule(projectRoot) {
-  const specifier = resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/realtime/server");
-  try {
-    return await import(specifier);
-  } catch (error) {
-    const details = error instanceof Error ? error.message : String(error);
-    if (/Cannot find module|ERR_MODULE_NOT_FOUND|MODULE_NOT_FOUND/i.test(details) && details.includes(specifier)) {
-      return null;
-    }
-    throw error;
-  }
-}
-function safeDecodeCookieSegment(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function readCookieFromHeader(header, name) {
-  for (const segment of header?.split(";") ?? []) {
-    const separator = segment.indexOf("=");
-    if (separator <= 0) {
-      continue;
-    }
-    const cookieName = safeDecodeCookieSegment(segment.slice(0, separator).trim());
-    if (cookieName === name) {
-      return safeDecodeCookieSegment(segment.slice(separator + 1).trim());
-    }
-  }
-  return void 0;
-}
-function createRealtimeAuthRequestAccessors(headers) {
-  return {
-    async getCookie(name) {
-      return readCookieFromHeader(headers.get("cookie"), name);
-    },
-    async getHeader(name) {
-      return headers.get(name) ?? void 0;
-    },
-    async appendResponseCookie(_cookie) {
-    },
-    async redirectResponse(url) {
-      throw new Error(`Realtime auth attempted to redirect to "${url}". Realtime requests cannot redirect.`);
-    }
-  };
-}
-async function createRealtimeWorkerBindings(projectRoot) {
-  if (!await hasProjectPackageDependency(projectRoot, "@holo-js/realtime")) {
-    return void 0;
-  }
-  const realtime = await loadRealtimeServerModule(projectRoot);
-  if (!realtime) {
-    return void 0;
-  }
-  const runtime = await initializeProjectRuntime(projectRoot);
-  realtime.configureRealtimeRuntime?.({
-    async runWithAuthRequestAccessors(accessors, callback) {
-      const runner = runtime.runWithAuthRequestAccessors;
-      return runner ? await runner(accessors, callback) : await callback();
-    }
-  });
-  const definitions = /* @__PURE__ */ new Map();
-  const resolveDefinition = async (name) => {
-    const cached = definitions.get(name);
-    if (cached) {
-      return await cached;
-    }
-    const resolved = realtime.resolveRealtimeDefinition(name, {
-      projectRoot,
-      importModule: async (absolutePath) => await importProjectModule(projectRoot, absolutePath)
-    }).catch((error) => {
-      definitions.delete(name);
-      throw error;
-    });
-    definitions.set(name, resolved);
-    return await resolved;
-  };
-  const withRealtimeRequest = async (context, callback) => {
-    return await callback(createRealtimeAuthRequestAccessors(context.headers));
-  };
-  return {
-    async query(name, args, context) {
-      return await withRealtimeRequest(context, async (authRequest) => {
-        return await realtime.executeRealtimeQuery(await resolveDefinition(name), args, { authRequest });
-      });
-    },
-    async mutate(name, args, context) {
-      return await withRealtimeRequest(context, async (authRequest) => {
-        return await realtime.executeRealtimeMutation(await resolveDefinition(name), args, { authRequest });
-      });
-    },
-    async subscribe(name, args, options) {
-      return await withRealtimeRequest(options.context, async (authRequest) => {
-        return await realtime.subscribeRealtimeQuery(await resolveDefinition(name), args, {
-          onData: options.onData,
-          onPatch: options.onPatch,
-          onError: options.onError
-        }, { authRequest });
-      });
-    }
-  };
-}
-async function runBroadcastWorkCommand(io, projectRoot, dependencies = {}) {
-  const loadConfig = dependencies.loadConfig ?? loadConfigDirectory;
-  const loadModule = dependencies.loadModule ?? loadBroadcastCliModule;
-  const config = await loadConfig(projectRoot);
-  const project = await loadProjectConfig(projectRoot);
-  const loadRegistry = dependencies.loadRegistry ?? loadGeneratedProjectRegistry;
-  await loadRegistry(projectRoot).catch(() => void 0);
-  const registry = await prepareProjectDiscovery(projectRoot, project.config);
-  const broadcastModule = await loadModule(projectRoot);
-  const realtime = await createRealtimeWorkerBindings(projectRoot);
-  const worker = await broadcastModule.startBroadcastWorker({
-    config: config.broadcast,
-    queue: config.queue,
-    ...hasLoadedRedisConfigSection(config.loadedFiles) ? { redis: config.redis } : {},
-    ...registry ? {
-      channelAuth: {
-        registry: {
-          projectRoot,
-          channels: registry.channels
-        },
-        importModule: async (absolutePath) => await importProjectModule(projectRoot, absolutePath)
-      }
-    } : {},
-    ...realtime ? { realtime } : {}
-  });
-  writeLine(io.stdout, `[broadcast] Worker listening on ${worker.host}:${worker.port}`);
-  await new Promise((resolvePromise) => {
-    let stopped = false;
-    const stop = async () => {
-      if (stopped) {
-        return;
-      }
-      stopped = true;
-      process.off("SIGINT", onSignal);
-      process.off("SIGTERM", onSignal);
-      await worker.stop();
-      resolvePromise();
-    };
-    const onSignal = () => {
-      void stop();
-    };
-    process.on("SIGINT", onSignal);
-    process.on("SIGTERM", onSignal);
-  });
-}
-export {
-  loadBroadcastCliModule,
-  runBroadcastWorkCommand
-};

package/dist/cache-DUVBBOZU.mjs

@@ -1,138 +0,0 @@
-import {
-  loadProjectDatabaseDrivers
-} from "./chunk-XBOVM6LO.mjs";
-import {
-  writeLine
-} from "./chunk-I7QBCEV7.mjs";
-import "./chunk-HX6MOYBO.mjs";
-import "./chunk-6BHJLCAO.mjs";
-import "./chunk-JVLZ3SOW.mjs";
-import "./chunk-QSVMXMTQ.mjs";
-import "./chunk-R4ZYMEDU.mjs";
-import "./chunk-3RFRE7XG.mjs";
-import "./chunk-TRYHX5S4.mjs";
-import {
-  resolveProjectPackageImportSpecifier
-} from "./chunk-YACY2572.mjs";
-
-// src/cache.ts
-import { loadConfigDirectory } from "@holo-js/config";
-import { unregisterDatabaseDriverFactory } from "@holo-js/db";
-var BUILT_IN_CACHE_DRIVER_NAMES = /* @__PURE__ */ new Set(["database", "file", "memory", "redis"]);
-var CONCRETE_CACHE_DRIVER_PACKAGES = {
-  database: "@holo-js/cache-db",
-  redis: "@holo-js/cache-redis"
-};
-async function loadConfiguredCacheDriverPackages(projectRoot, drivers, loadPackage = (specifier) => import(specifier)) {
-  const configuredDrivers = new Set(Object.values(drivers).map(resolveConfiguredCacheDriverName));
-  for (const driver of configuredDrivers) {
-    if (driver !== "database" && driver !== "redis") continue;
-    const packageName = CONCRETE_CACHE_DRIVER_PACKAGES[driver];
-    try {
-      await loadPackage(resolveProjectPackageImportSpecifier(projectRoot, packageName));
-    } catch (error) {
-      throw new Error(
-        `[Holo CLI] Cache driver "${driver}" requires ${packageName} to be installed.`,
-        { cause: error }
-      );
-    }
-  }
-}
-function resolveCacheFacade(cacheModule) {
-  const candidate = cacheModule.default;
-  if (candidate) {
-    return candidate;
-  }
-  return cacheModule;
-}
-function resolveConfiguredCacheDriverName(driverConfig) {
-  if (!driverConfig || typeof driverConfig !== "object" || Array.isArray(driverConfig)) {
-    return void 0;
-  }
-  const value = driverConfig.driver;
-  return typeof value === "string" ? value : void 0;
-}
-function resolveCachePluginDriverLoader(cacheModule, cache, drivers, requestedDriverName, defaultDriverName) {
-  const loadCachePluginDrivers = ("loadCachePluginDrivers" in cache ? cache.loadCachePluginDrivers?.bind(cache) : void 0) ?? ("loadCachePluginDrivers" in cacheModule ? cacheModule.loadCachePluginDrivers?.bind(cacheModule) : void 0);
-  const storeName = requestedDriverName?.trim() || defaultDriverName;
-  const driverName = resolveConfiguredCacheDriverName(drivers[storeName]);
-  if (!driverName || BUILT_IN_CACHE_DRIVER_NAMES.has(driverName)) {
-    return void 0;
-  }
-  if (loadCachePluginDrivers) {
-    return loadCachePluginDrivers;
-  }
-  throw new Error(
-    `[Holo CLI] Cache store "${storeName}" uses plugin driver "${driverName}", but the installed @holo-js/cache package does not support cache plugin drivers.`
-  );
-}
-var cacheCommandInternals = {
-  loadConfiguredCacheDriverPackages,
-  resolveCachePluginDriverLoader
-};
-async function loadCacheCliModule(projectRoot) {
-  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/cache"));
-}
-async function initializeCacheMaintenanceEnvironment(projectRoot, driverName) {
-  const loadedConfig = await loadConfigDirectory(projectRoot);
-  const databaseDriverFactories = await loadProjectDatabaseDrivers(projectRoot, loadedConfig.database);
-  const cacheModule = await loadCacheCliModule(projectRoot);
-  const cache = resolveCacheFacade(cacheModule);
-  await loadConfiguredCacheDriverPackages(projectRoot, loadedConfig.cache.drivers);
-  const loadCachePluginDrivers = resolveCachePluginDriverLoader(
-    cacheModule,
-    cache,
-    loadedConfig.cache.drivers,
-    driverName,
-    loadedConfig.cache.default
-  );
-  cache.configureCacheRuntime({
-    config: loadedConfig.cache,
-    databaseConfig: loadedConfig.database,
-    redisConfig: loadedConfig.redis
-  });
-  if (loadCachePluginDrivers) {
-    try {
-      await loadCachePluginDrivers(projectRoot, loadedConfig.app.plugins);
-    } catch (error) {
-      cache.resetCacheRuntime();
-      throw error;
-    }
-  }
-  return {
-    cache,
-    async cleanup() {
-      cache.resetCacheRuntime();
-      for (const factory of [...databaseDriverFactories].reverse()) {
-        unregisterDatabaseDriverFactory(factory);
-      }
-    }
-  };
-}
-async function runCacheClearCommand(io, projectRoot, driverName, dependencies = {}) {
-  const environment = await (dependencies.initializeCache ?? initializeCacheMaintenanceEnvironment)(projectRoot, driverName);
-  try {
-    const repository = driverName?.trim() ? environment.cache.driver(driverName) : environment.cache;
-    await (dependencies.flush ?? (async (target) => await target.flush()))(repository);
-    writeLine(io.stdout, driverName?.trim() ? `[cache] Cleared cache store "${driverName}".` : "[cache] Cleared the default cache store.");
-  } finally {
-    await environment.cleanup();
-  }
-}
-async function runCacheForgetCommand(io, projectRoot, key, driverName, dependencies = {}) {
-  const environment = await (dependencies.initializeCache ?? initializeCacheMaintenanceEnvironment)(projectRoot, driverName);
-  try {
-    const repository = driverName?.trim() ? environment.cache.driver(driverName) : environment.cache;
-    const forgotten = await (dependencies.forget ?? (async (target, targetKey) => await target.forget(targetKey)))(repository, key);
-    writeLine(io.stdout, forgotten ? `[cache] Forgot key "${key}".` : `[cache] Key "${key}" was not present.`);
-  } finally {
-    await environment.cleanup();
-  }
-}
-export {
-  cacheCommandInternals,
-  initializeCacheMaintenanceEnvironment,
-  loadCacheCliModule,
-  runCacheClearCommand,
-  runCacheForgetCommand
-};

package/dist/cache-migrations-PD2T5AV4.mjs

@@ -1,175 +0,0 @@
-import {
-  runProjectPrepare
-} from "./chunk-TH5YCOZB.mjs";
-import "./chunk-LHK5YUR4.mjs";
-import {
-  getRegistryMigrationSlug,
-  hasRegisteredCreateTableMigration,
-  hasRegisteredMigrationSlug,
-  nextMigrationTemplate
-} from "./chunk-OLZEMIDQ.mjs";
-import "./chunk-M3IPUCTM.mjs";
-import {
-  writeLine
-} from "./chunk-I7QBCEV7.mjs";
-import "./chunk-HX6MOYBO.mjs";
-import "./chunk-6BHJLCAO.mjs";
-import {
-  ensureProjectConfig
-} from "./chunk-JVLZ3SOW.mjs";
-import {
-  prepareProjectDiscovery
-} from "./chunk-QSVMXMTQ.mjs";
-import {
-  loadGeneratedProjectRegistry
-} from "./chunk-R4ZYMEDU.mjs";
-import "./chunk-3RFRE7XG.mjs";
-import "./chunk-TRYHX5S4.mjs";
-import {
-  makeProjectRelativePath,
-  resolveDefaultArtifactPath,
-  writeTextFile
-} from "./chunk-YACY2572.mjs";
-
-// src/cache-migrations.ts
-import { resolve } from "path";
-import {
-  CACHE_DATABASE_TABLE_DEFINITIONS,
-  DEFAULT_CACHE_DATABASE_LOCK_TABLE as CACHE_DB_DEFAULT_LOCK_TABLE,
-  DEFAULT_CACHE_DATABASE_TABLE as CACHE_DB_DEFAULT_TABLE
-} from "@holo-js/cache-db";
-import { loadConfigDirectory } from "@holo-js/config";
-import { normalizeMigrationSlug } from "@holo-js/db";
-var DEFAULT_CACHE_DATABASE_TABLE = CACHE_DB_DEFAULT_TABLE;
-var DEFAULT_CACHE_DATABASE_LOCK_TABLE = CACHE_DB_DEFAULT_LOCK_TABLE;
-async function loadCacheConfig(projectRoot) {
-  const loadedConfig = await loadConfigDirectory(projectRoot);
-  if (!loadedConfig || typeof loadedConfig !== "object" || !("cache" in loadedConfig) || !loadedConfig.cache || typeof loadedConfig.cache !== "object" || !("drivers" in loadedConfig.cache) || typeof loadedConfig.cache.drivers !== "object" || loadedConfig.cache.drivers === null || Array.isArray(loadedConfig.cache.drivers)) {
-    throw new Error("Cache config is missing or malformed. Expected a cache config object with a drivers property.");
-  }
-  const cacheConfig = loadedConfig.cache;
-  for (const [driverName, driverConfig] of Object.entries(cacheConfig.drivers)) {
-    if (driverConfig.driver !== "database") {
-      continue;
-    }
-    const databaseDriver = driverConfig;
-    if (typeof databaseDriver.table !== "string" || !databaseDriver.table.trim() || typeof databaseDriver.lockTable !== "string" || !databaseDriver.lockTable.trim()) {
-      throw new Error(`Database cache driver "${driverName}" must define non-empty "table" and "lockTable" strings.`);
-    }
-  }
-  return cacheConfig;
-}
-function normalizeCacheMigrationName(tableName) {
-  return normalizeMigrationSlug(`create_${tableName.replaceAll(".", "_")}_cache_table`);
-}
-function escapeSingleQuotedString(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
-}
-function renderCacheTableColumn(columnDefinition) {
-  const calls = [
-    `table.${columnDefinition.kind}('${escapeSingleQuotedString(columnDefinition.name)}')`
-  ];
-  if (columnDefinition.primaryKey) {
-    calls.push("primaryKey()");
-  }
-  if (columnDefinition.nullable) {
-    calls.push("nullable()");
-  }
-  return `      ${calls.join(".")}`;
-}
-function renderCacheTableCreateStatement(tableName, tableDefinition) {
-  return [
-    `    await schema.createTable('${escapeSingleQuotedString(tableName)}', (table) => {`,
-    ...tableDefinition.columns.map(renderCacheTableColumn),
-    `      table.index(['${escapeSingleQuotedString(tableDefinition.indexColumn)}'], '${escapeSingleQuotedString(tableDefinition.indexName(tableName))}')`,
-    "    })"
-  ];
-}
-function resolveCacheDatabaseTableDefinition(role) {
-  const tableDefinition = CACHE_DATABASE_TABLE_DEFINITIONS.find((definition) => definition.role === role);
-  if (!tableDefinition) {
-    throw new Error(`Missing cache database table definition for "${role}".`);
-  }
-  return tableDefinition;
-}
-function renderCacheTableMigration(tableName = DEFAULT_CACHE_DATABASE_TABLE, lockTableName = DEFAULT_CACHE_DATABASE_LOCK_TABLE) {
-  const entryTableDefinition = resolveCacheDatabaseTableDefinition("entries");
-  const lockTableDefinition = resolveCacheDatabaseTableDefinition("locks");
-  return [
-    "import { defineMigration } from '@holo-js/db'",
-    "",
-    "export default defineMigration({",
-    "  async up({ schema }) {",
-    ...renderCacheTableCreateStatement(tableName, entryTableDefinition),
-    ...renderCacheTableCreateStatement(lockTableName, lockTableDefinition),
-    "  },",
-    "  async down({ schema }) {",
-    `    await schema.dropTable('${escapeSingleQuotedString(lockTableName)}')`,
-    `    await schema.dropTable('${escapeSingleQuotedString(tableName)}')`,
-    "  },",
-    "})",
-    ""
-  ].join("\n");
-}
-function resolveDatabaseCacheTables(cacheConfig) {
-  const configured = Object.values(cacheConfig.drivers).filter((driver) => driver.driver === "database").map((driver) => ({
-    table: driver.table,
-    lockTable: driver.lockTable
-  }));
-  if (configured.length === 0) {
-    throw new Error("The configured cache drivers do not use the database driver.");
-  }
-  return Object.freeze(configured);
-}
-async function runCacheTableCommand(io, projectRoot) {
-  const project = await ensureProjectConfig(projectRoot);
-  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
-  const cacheConfig = await loadCacheConfig(projectRoot);
-  const migrationsDir = resolve(projectRoot, project.config.paths.migrations);
-  const createdFiles = [];
-  const resolvedTables = resolveDatabaseCacheTables(cacheConfig);
-  const seenPhysicalTables = /* @__PURE__ */ new Set();
-  const seenSlugs = /* @__PURE__ */ new Map();
-  for (const { table, lockTable } of resolvedTables) {
-    const migrationName = normalizeCacheMigrationName(table);
-    const previousTable = seenSlugs.get(migrationName);
-    if (table === lockTable || seenPhysicalTables.has(table) || seenPhysicalTables.has(lockTable) || previousTable && previousTable !== table) {
-      throw new Error(`A migration for cache tables "${table}" and "${lockTable}" already exists.`);
-    }
-    seenPhysicalTables.add(table);
-    seenPhysicalTables.add(lockTable);
-    seenSlugs.set(migrationName, table);
-  }
-  for (const { table, lockTable } of resolvedTables) {
-    const migrationName = normalizeCacheMigrationName(table);
-    if (hasRegisteredMigrationSlug(registry, migrationName) || hasRegisteredCreateTableMigration(registry, table) || hasRegisteredCreateTableMigration(registry, lockTable)) {
-      throw new Error(`A migration for cache tables "${table}" and "${lockTable}" already exists.`);
-    }
-  }
-  for (const { table, lockTable } of resolvedTables) {
-    const migrationTemplate = await nextMigrationTemplate(normalizeCacheMigrationName(table), migrationsDir);
-    const migrationFilePath = resolveDefaultArtifactPath(projectRoot, project.config.paths.migrations, migrationTemplate.fileName);
-    await writeTextFile(migrationFilePath, renderCacheTableMigration(table, lockTable));
-    createdFiles.push(migrationFilePath);
-  }
-  await runProjectPrepare(projectRoot);
-  for (const filePath of createdFiles) {
-    writeLine(io.stdout, `Created migration: ${makeProjectRelativePath(projectRoot, filePath)}`);
-  }
-}
-var cacheMigrationInternals = {
-  getRegistryMigrationSlug,
-  hasRegisteredMigrationSlug,
-  hasRegisteredCreateTableMigration,
-  nextMigrationTemplate
-};
-export {
-  DEFAULT_CACHE_DATABASE_LOCK_TABLE,
-  DEFAULT_CACHE_DATABASE_TABLE,
-  cacheMigrationInternals,
-  loadCacheConfig,
-  normalizeCacheMigrationName,
-  renderCacheTableMigration,
-  resolveDatabaseCacheTables,
-  runCacheTableCommand
-};

package/dist/chunk-HX6MOYBO.mjs

@@ -1,2 +0,0 @@
-// src/project.ts
-import { normalizeHoloProjectConfig } from "@holo-js/kernel";