@holo-js/cli 0.1.8 → 0.2.0

package/dist/broadcast-YWS4N5QU.mjs

@@ -0,0 +1,203 @@
+import {
+  writeLine
+} from "./chunk-I7QBCEV7.mjs";
+import {
+  initializeProjectRuntime
+} from "./chunk-IUDD5FYL.mjs";
+import "./chunk-LBJAJLKU.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-2RGJTPYF.mjs";
+import "./chunk-UPZH6KCF.mjs";
+import {
+  loadProjectConfig
+} from "./chunk-ONKESAQA.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-2DKQKZML.mjs";
+import {
+  importProjectModule,
+  resolveProjectPackageImportSpecifier
+} from "./chunk-ILU426CF.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,
+          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-JGGCYQQG.mjs → cache-KWNQECAA.mjs}

@@ -1,14 +1,14 @@
 import {
   writeLine
-} from "./chunk-ZXDU7RHU.mjs";
+} from "./chunk-I7QBCEV7.mjs";
 import "./chunk-D7O4SU6N.mjs";
-import "./chunk-D4NXGVV4.mjs";
-import "./chunk-SABHUOON.mjs";
-import "./chunk-DFKX4YT4.mjs";
-import "./chunk-O6AXHL7Z.mjs";
+import "./chunk-2RGJTPYF.mjs";
+import "./chunk-KWRIBHC3.mjs";
+import "./chunk-ONKESAQA.mjs";
+import "./chunk-2DKQKZML.mjs";
 import {
   resolveProjectPackageImportSpecifier
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/cache.ts
 import { loadConfigDirectory } from "@holo-js/config";

package/dist/cache-QARFSW4F.mjs

@@ -0,0 +1,66 @@
+import {
+  writeLine
+} from "./chunk-I7QBCEV7.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import "./chunk-2RGJTPYF.mjs";
+import "./chunk-UPZH6KCF.mjs";
+import "./chunk-ONKESAQA.mjs";
+import "./chunk-2DKQKZML.mjs";
+import {
+  resolveProjectPackageImportSpecifier
+} from "./chunk-ILU426CF.mjs";
+
+// src/cache.ts
+import { loadConfigDirectory } from "@holo-js/config";
+function resolveCacheFacade(cacheModule) {
+  const candidate = cacheModule.default;
+  if (candidate) {
+    return candidate;
+  }
+  return cacheModule;
+}
+async function loadCacheCliModule(projectRoot) {
+  return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/cache"));
+}
+async function initializeCacheMaintenanceEnvironment(projectRoot) {
+  const loadedConfig = await loadConfigDirectory(projectRoot);
+  const cacheModule = await loadCacheCliModule(projectRoot);
+  const cache = resolveCacheFacade(cacheModule);
+  cache.configureCacheRuntime({
+    config: loadedConfig.cache,
+    databaseConfig: loadedConfig.database,
+    redisConfig: loadedConfig.redis
+  });
+  return {
+    cache,
+    async cleanup() {
+      cache.resetCacheRuntime();
+    }
+  };
+}
+async function runCacheClearCommand(io, projectRoot, driverName, dependencies = {}) {
+  const environment = await (dependencies.initializeCache ?? initializeCacheMaintenanceEnvironment)(projectRoot);
+  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);
+  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 {
+  initializeCacheMaintenanceEnvironment,
+  loadCacheCliModule,
+  runCacheClearCommand,
+  runCacheForgetCommand
+};

package/dist/{cache-migrations-3V7LI4CC.mjs → cache-migrations-3OXR4FN5.mjs}

@@ -1,40 +1,45 @@
 import {
   runProjectPrepare
-} from "./chunk-2NUEWM2P.mjs";
-import "./chunk-F4MT6GBK.mjs";
+} from "./chunk-EWYXSN2C.mjs";
+import "./chunk-FGQ2I2YH.mjs";
 import {
   getRegistryMigrationSlug,
   hasRegisteredCreateTableMigration,
   hasRegisteredMigrationSlug,
   nextMigrationTemplate
-} from "./chunk-BAFQ2GOA.mjs";
+} from "./chunk-LXGQCG56.mjs";
 import {
   writeLine
-} from "./chunk-ZXDU7RHU.mjs";
-import "./chunk-57SJ566R.mjs";
+} from "./chunk-I7QBCEV7.mjs";
+import "./chunk-LBJAJLKU.mjs";
 import "./chunk-D7O4SU6N.mjs";
 import {
   prepareProjectDiscovery
-} from "./chunk-D4NXGVV4.mjs";
-import "./chunk-SABHUOON.mjs";
+} from "./chunk-2RGJTPYF.mjs";
+import "./chunk-UPZH6KCF.mjs";
 import {
   ensureProjectConfig
-} from "./chunk-DFKX4YT4.mjs";
+} from "./chunk-ONKESAQA.mjs";
 import {
   loadGeneratedProjectRegistry
-} from "./chunk-O6AXHL7Z.mjs";
+} from "./chunk-2DKQKZML.mjs";
 import {
   makeProjectRelativePath,
   resolveDefaultArtifactPath,
   writeTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.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";
-var DEFAULT_CACHE_DATABASE_LOCK_TABLE = "cache_locks";
+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)) {
@@ -58,32 +63,47 @@ function normalizeCacheMigrationName(tableName) {
 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 escapedTableName = escapeSingleQuotedString(tableName);
-  const escapedLockTableName = escapeSingleQuotedString(lockTableName);
-  const escapedTableIndexName = escapeSingleQuotedString(`${tableName.replaceAll(".", "_")}_expires_at_index`);
-  const escapedLockTableIndexName = escapeSingleQuotedString(`${lockTableName.replaceAll(".", "_")}_expires_at_index`);
+  const entryTableDefinition = resolveCacheDatabaseTableDefinition("entries");
+  const lockTableDefinition = resolveCacheDatabaseTableDefinition("locks");
   return [
     "import { defineMigration, type MigrationContext } from '@holo-js/db'",
     "",
     "export default defineMigration({",
     "  async up({ schema }: MigrationContext) {",
-    `    await schema.createTable('${escapedTableName}', (table) => {`,
-    "      table.string('key').primaryKey()",
-    "      table.text('payload')",
-    "      table.bigInteger('expires_at').nullable()",
-    `      table.index(['expires_at'], '${escapedTableIndexName}')`,
-    "    })",
-    `    await schema.createTable('${escapedLockTableName}', (table) => {`,
-    "      table.string('name').primaryKey()",
-    "      table.string('owner')",
-    "      table.bigInteger('expires_at')",
-    `      table.index(['expires_at'], '${escapedLockTableIndexName}')`,
-    "    })",
+    ...renderCacheTableCreateStatement(tableName, entryTableDefinition),
+    ...renderCacheTableCreateStatement(lockTableName, lockTableDefinition),
     "  },",
     "  async down({ schema }: MigrationContext) {",
-    `    await schema.dropTable('${escapedLockTableName}')`,
-    `    await schema.dropTable('${escapedTableName}')`,
+    `    await schema.dropTable('${escapeSingleQuotedString(lockTableName)}')`,
+    `    await schema.dropTable('${escapeSingleQuotedString(tableName)}')`,
     "  },",
     "})",
     ""

package/dist/cache-migrations-MDFMDVTK.mjs

@@ -0,0 +1,173 @@
+import {
+  runProjectPrepare
+} from "./chunk-QA7TP5EO.mjs";
+import "./chunk-FGQ2I2YH.mjs";
+import {
+  getRegistryMigrationSlug,
+  hasRegisteredCreateTableMigration,
+  hasRegisteredMigrationSlug,
+  nextMigrationTemplate
+} from "./chunk-LXGQCG56.mjs";
+import "./chunk-LBJAJLKU.mjs";
+import {
+  writeLine
+} from "./chunk-I7QBCEV7.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-2RGJTPYF.mjs";
+import "./chunk-KWRIBHC3.mjs";
+import {
+  ensureProjectConfig
+} from "./chunk-ONKESAQA.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-2DKQKZML.mjs";
+import {
+  makeProjectRelativePath,
+  resolveDefaultArtifactPath,
+  writeTextFile
+} from "./chunk-ILU426CF.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, type MigrationContext } from '@holo-js/db'",
+    "",
+    "export default defineMigration({",
+    "  async up({ schema }: MigrationContext) {",
+    ...renderCacheTableCreateStatement(tableName, entryTableDefinition),
+    ...renderCacheTableCreateStatement(lockTableName, lockTableDefinition),
+    "  },",
+    "  async down({ schema }: MigrationContext) {",
+    `    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
+};