@holo-js/cli 0.1.9 → 0.2.1

package/dist/queue-migrations-O24ERNFF.mjs

@@ -0,0 +1,167 @@
+import {
+  runProjectPrepare
+} from "./chunk-SFRAGRHY.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-VP2E62DF.mjs";
+import "./chunk-MCVRN7KX.mjs";
+import {
+  ensureProjectConfig
+} from "./chunk-YEFJBN56.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-J76GH2DR.mjs";
+import {
+  makeProjectRelativePath,
+  resolveDefaultArtifactPath,
+  writeTextFile
+} from "./chunk-ILU426CF.mjs";
+
+// src/queue-migrations.ts
+import { resolve } from "path";
+import { loadConfigDirectory } from "@holo-js/config";
+import { normalizeMigrationSlug } from "@holo-js/db";
+var DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
+var DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
+async function loadQueueConfig(projectRoot) {
+  return (await loadConfigDirectory(projectRoot)).queue;
+}
+function normalizeQueueMigrationName(tableName) {
+  return normalizeMigrationSlug(`create_${tableName.replaceAll(".", "_")}_table`);
+}
+function renderQueueTableMigration(tableName) {
+  const tableNameLiteral = JSON.stringify(tableName);
+  const indexPrefix = tableName.replaceAll(".", "_");
+  return [
+    "import { defineMigration, type MigrationContext } from '@holo-js/db'",
+    "",
+    "export default defineMigration({",
+    "  async up({ schema }: MigrationContext) {",
+    `    await schema.createTable(${tableNameLiteral}, (table) => {`,
+    "      table.string('id').primaryKey()",
+    "      table.string('job')",
+    "      table.string('connection')",
+    "      table.string('queue')",
+    "      table.text('payload')",
+    "      table.integer('attempts').default(0)",
+    "      table.integer('max_attempts').default(1)",
+    "      table.bigInteger('available_at')",
+    "      table.bigInteger('reserved_at').nullable()",
+    "      table.string('reservation_id').nullable()",
+    "      table.bigInteger('created_at')",
+    `      table.index(['queue', 'available_at'], ${JSON.stringify(`${indexPrefix}_queue_available_at_index`)})`,
+    `      table.index(['queue', 'reserved_at'], ${JSON.stringify(`${indexPrefix}_queue_reserved_at_index`)})`,
+    `      table.index(['reservation_id'], ${JSON.stringify(`${indexPrefix}_reservation_id_index`)})`,
+    "    })",
+    "  },",
+    "  async down({ schema }: MigrationContext) {",
+    `    await schema.dropTable(${tableNameLiteral})`,
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderFailedJobsTableMigration(tableName) {
+  const tableNameLiteral = JSON.stringify(tableName);
+  const indexPrefix = tableName.replaceAll(".", "_");
+  return [
+    "import { defineMigration, type MigrationContext } from '@holo-js/db'",
+    "",
+    "export default defineMigration({",
+    "  async up({ schema }: MigrationContext) {",
+    `    await schema.createTable(${tableNameLiteral}, (table) => {`,
+    "      table.string('id').primaryKey()",
+    "      table.string('job_id')",
+    "      table.string('job')",
+    "      table.string('connection')",
+    "      table.string('queue')",
+    "      table.text('payload')",
+    "      table.text('exception')",
+    "      table.bigInteger('failed_at')",
+    `      table.index(['job_id'], ${JSON.stringify(`${indexPrefix}_job_id_index`)})`,
+    `      table.index(['failed_at'], ${JSON.stringify(`${indexPrefix}_failed_at_index`)})`,
+    "    })",
+    "  },",
+    "  async down({ schema }: MigrationContext) {",
+    `    await schema.dropTable(${tableNameLiteral})`,
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function resolveDatabaseQueueTables(queueConfig) {
+  const configured = Object.values(queueConfig.connections).filter((connection) => connection.driver === "database").map((connection) => connection.table);
+  return Object.freeze(configured.length > 0 ? [...new Set(configured)] : [DEFAULT_DATABASE_QUEUE_TABLE]);
+}
+async function runQueueTableCommand(io, projectRoot) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const queueConfig = await loadQueueConfig(projectRoot);
+  const migrationsDir = resolve(projectRoot, project.config.paths.migrations);
+  const createdFiles = [];
+  const tableNames = resolveDatabaseQueueTables(queueConfig);
+  for (const tableName of tableNames) {
+    const migrationName = normalizeQueueMigrationName(tableName);
+    if (hasRegisteredMigrationSlug(registry, migrationName) || hasRegisteredCreateTableMigration(registry, tableName)) {
+      throw new Error(`A migration for table "${tableName}" already exists.`);
+    }
+  }
+  for (const tableName of tableNames) {
+    const migrationTemplate = await nextMigrationTemplate(normalizeQueueMigrationName(tableName), migrationsDir);
+    const migrationFilePath = resolveDefaultArtifactPath(projectRoot, project.config.paths.migrations, migrationTemplate.fileName);
+    await writeTextFile(migrationFilePath, renderQueueTableMigration(tableName));
+    createdFiles.push(migrationFilePath);
+  }
+  await runProjectPrepare(projectRoot);
+  for (const filePath of createdFiles) {
+    writeLine(io.stdout, `Created migration: ${makeProjectRelativePath(projectRoot, filePath)}`);
+  }
+}
+async function runQueueFailedTableCommand(io, projectRoot) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const queueConfig = await loadQueueConfig(projectRoot);
+  const tableName = queueConfig.failed === false ? DEFAULT_FAILED_JOBS_TABLE : queueConfig.failed.table;
+  const migrationName = normalizeQueueMigrationName(tableName);
+  if (hasRegisteredMigrationSlug(registry, migrationName) || hasRegisteredCreateTableMigration(registry, tableName)) {
+    throw new Error(`A migration for table "${tableName}" already exists.`);
+  }
+  const migrationTemplate = await nextMigrationTemplate(
+    migrationName,
+    resolve(projectRoot, project.config.paths.migrations)
+  );
+  const migrationFilePath = resolveDefaultArtifactPath(projectRoot, project.config.paths.migrations, migrationTemplate.fileName);
+  await writeTextFile(migrationFilePath, renderFailedJobsTableMigration(tableName));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created migration: ${makeProjectRelativePath(projectRoot, migrationFilePath)}`);
+}
+var queueMigrationInternals = {
+  getRegistryMigrationSlug,
+  hasRegisteredMigrationSlug,
+  hasRegisteredCreateTableMigration,
+  nextMigrationTemplate
+};
+export {
+  DEFAULT_DATABASE_QUEUE_TABLE,
+  DEFAULT_FAILED_JOBS_TABLE,
+  loadQueueConfig,
+  normalizeQueueMigrationName,
+  queueMigrationInternals,
+  renderFailedJobsTableMigration,
+  renderQueueTableMigration,
+  resolveDatabaseQueueTables,
+  runQueueFailedTableCommand,
+  runQueueTableCommand
+};

package/dist/{runtime-BI343WHS.mjs → runtime-2AA7ZLJ6.mjs}

@@ -14,22 +14,22 @@ import {
   initializeProjectRuntime,
   isDefined,
   mergeRuntimeDatabaseConfig,
-  nodeRuntimeScript,
   normalizeRuntimeConnectionInput,
   normalizeRuntimeMigration,
   parseBooleanEnv,
   resolveConfigModuleUrl,
   resolvePackageRootFromSpecifier,
+  resolveRuntimeWorkerPath,
   runRuntimeInvocation,
   withRuntimeEnvironment
-} from "./chunk-HB4Q7VYK.mjs";
-import "./chunk-57SJ566R.mjs";
+} from "./chunk-KS5TWO75.mjs";
+import "./chunk-LBJAJLKU.mjs";
 import "./chunk-D7O4SU6N.mjs";
-import "./chunk-7JR73TOH.mjs";
-import "./chunk-WRZFATUT.mjs";
-import "./chunk-SRPGIWCF.mjs";
-import "./chunk-IMOGEKB4.mjs";
-import "./chunk-R6BWRY3E.mjs";
+import "./chunk-VP2E62DF.mjs";
+import "./chunk-MCVRN7KX.mjs";
+import "./chunk-YEFJBN56.mjs";
+import "./chunk-J76GH2DR.mjs";
+import "./chunk-ILU426CF.mjs";
 export {
   RUNTIME_MIGRATION_NAME_PATTERN,
   cacheProjectConfig,
@@ -46,12 +46,12 @@ export {
   initializeProjectRuntime,
   isDefined,
   mergeRuntimeDatabaseConfig,
-  nodeRuntimeScript,
   normalizeRuntimeConnectionInput,
   normalizeRuntimeMigration,
   parseBooleanEnv,
   resolveConfigModuleUrl,
   resolvePackageRootFromSpecifier,
+  resolveRuntimeWorkerPath,
   runRuntimeInvocation,
   withRuntimeEnvironment
 };

package/dist/{runtime-ZKD6URAV.mjs → runtime-GSXF4NB3.mjs}

@@ -13,7 +13,7 @@ import {
   resolveProjectPackageImportSpecifier,
   setProjectModuleBundlerForTesting,
   writeTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 export {
   bundleProjectModule,
   findProjectRoot,

package/dist/runtime-HGK2MWSC.mjs

@@ -0,0 +1,57 @@
+import {
+  RUNTIME_MIGRATION_NAME_PATTERN,
+  cacheProjectConfig,
+  cleanupRuntimeDependencyLink,
+  compileFreshDropIdentifierPath,
+  createEnvRuntimeConfig,
+  createRuntimeInvocation,
+  dropAllTablesForFresh,
+  ensureRuntimeDependencyLink,
+  filterDefinedRuntimeConnectionInput,
+  getRuntimeEnvironment,
+  getRuntimeFailureMessage,
+  inferRuntimeMigrationName,
+  initializeProjectRuntime,
+  isDefined,
+  mergeRuntimeDatabaseConfig,
+  normalizeRuntimeConnectionInput,
+  normalizeRuntimeMigration,
+  parseBooleanEnv,
+  resolveConfigModuleUrl,
+  resolvePackageRootFromSpecifier,
+  resolveRuntimeWorkerPath,
+  runRuntimeInvocation,
+  withRuntimeEnvironment
+} from "./chunk-KS5TWO75.mjs";
+import "./chunk-LBJAJLKU.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import "./chunk-VP2E62DF.mjs";
+import "./chunk-4OHJC3GL.mjs";
+import "./chunk-YEFJBN56.mjs";
+import "./chunk-J76GH2DR.mjs";
+import "./chunk-ILU426CF.mjs";
+export {
+  RUNTIME_MIGRATION_NAME_PATTERN,
+  cacheProjectConfig,
+  cleanupRuntimeDependencyLink,
+  compileFreshDropIdentifierPath,
+  createEnvRuntimeConfig,
+  createRuntimeInvocation,
+  dropAllTablesForFresh,
+  ensureRuntimeDependencyLink,
+  filterDefinedRuntimeConnectionInput,
+  getRuntimeEnvironment,
+  getRuntimeFailureMessage,
+  inferRuntimeMigrationName,
+  initializeProjectRuntime,
+  isDefined,
+  mergeRuntimeDatabaseConfig,
+  normalizeRuntimeConnectionInput,
+  normalizeRuntimeMigration,
+  parseBooleanEnv,
+  resolveConfigModuleUrl,
+  resolvePackageRootFromSpecifier,
+  resolveRuntimeWorkerPath,
+  runRuntimeInvocation,
+  withRuntimeEnvironment
+};

package/dist/runtime-worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/runtime-worker.mjs

@@ -0,0 +1,276 @@
+// src/runtime-worker.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import {
+  configureDB,
+  createMigrationService,
+  createSchemaService,
+  createSeederService,
+  registerGeneratedTables,
+  renderGeneratedSchemaModule,
+  renderGeneratedSchemaRuntimeModule,
+  resetDB,
+  resolveRuntimeConnectionManagerOptions
+} from "@holo-js/db";
+var payload = JSON.parse(process.env.HOLO_RUNTIME_PAYLOAD ?? "{}");
+if (typeof payload.projectRoot === "string") {
+  process.chdir(payload.projectRoot);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function loadModule(path) {
+  return import(`${path}?t=${Date.now()}`);
+}
+function resolveExport(moduleValue, matcher) {
+  if (isRecord(moduleValue) && matcher(moduleValue.default)) {
+    return moduleValue.default;
+  }
+  if (isRecord(moduleValue)) {
+    for (const value of Object.values(moduleValue)) {
+      if (matcher(value)) {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function isModel(value) {
+  return isRecord(value) && isRecord(value.definition) && value.definition.kind === "model" && typeof value.definition.name === "string" && typeof value.prune === "function";
+}
+function isMigration(value) {
+  return isRecord(value) && typeof value.up === "function";
+}
+function isSeeder(value) {
+  return isRecord(value) && typeof value.name === "string" && typeof value.run === "function";
+}
+function isTable(value) {
+  return isRecord(value) && value.kind === "table" && typeof value.tableName === "string" && isRecord(value.columns) && Array.isArray(value.indexes);
+}
+function extractTables(moduleValue) {
+  if (isRecord(moduleValue) && isRecord(moduleValue.tables)) {
+    return Object.values(moduleValue.tables).filter(isTable);
+  }
+  if (isRecord(moduleValue) && isTable(moduleValue.default)) {
+    return [moduleValue.default];
+  }
+  if (isRecord(moduleValue)) {
+    return Object.values(moduleValue).filter(isTable);
+  }
+  return [];
+}
+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 preloadGeneratedSchema(manager2, entry) {
+  if (!entry) {
+    return;
+  }
+  const tables = extractTables(await loadModule(entry));
+  for (const table of tables) {
+    manager2.connection().getSchemaRegistry().replace(table);
+  }
+}
+async function writeGeneratedSchemaArtifact(manager2, outputPath, runtimeOutputPath) {
+  if (!outputPath && !runtimeOutputPath) {
+    return;
+  }
+  const tables = manager2.connection().getSchemaRegistry().list();
+  if (outputPath) {
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, renderGeneratedSchemaModule(tables), "utf8");
+  }
+  if (runtimeOutputPath) {
+    await mkdir(dirname(runtimeOutputPath), { recursive: true });
+    await writeFile(runtimeOutputPath, renderGeneratedSchemaRuntimeModule(tables), "utf8");
+  }
+}
+function syncGeneratedSchemaFromManager(manager2) {
+  registerGeneratedTables(Object.fromEntries(
+    manager2.connection().getSchemaRegistry().list().map((table) => [table.tableName, table])
+  ));
+}
+async function hydrateGeneratedSchemaFromRanMigrations(manager2, migrations) {
+  const migrationService = createMigrationService(manager2.connection(), migrations);
+  const ranNames = new Set(
+    (await migrationService.status()).filter((status) => status.status === "ran").map((status) => status.name)
+  );
+  if (ranNames.size === 0) {
+    return;
+  }
+  const realConnection = manager2.connection();
+  const dryRunConnection = {
+    getDialect: () => realConnection.getDialect(),
+    getCapabilities: () => realConnection.getCapabilities(),
+    getSchemaName: () => realConnection.getSchemaName(),
+    getSchemaRegistry: () => realConnection.getSchemaRegistry(),
+    executeCompiled: async () => void 0,
+    introspectCompiled: async () => ({ rows: [], rowCount: 0 }),
+    transaction: async (callback) => callback(dryRunConnection)
+  };
+  const schema = createSchemaService(dryRunConnection);
+  for (const migration of [...migrations].sort((left, right) => left.name.localeCompare(right.name))) {
+    if (ranNames.has(migration.name)) {
+      await migration.up({ db: dryRunConnection, schema });
+    }
+  }
+}
+async function loadRuntimeItems(entries, matcher, label) {
+  const items = [];
+  for (const entry of entries) {
+    const item = resolveExport(await loadModule(entry), matcher);
+    if (!item) {
+      throw new Error(`Registered ${label} "${entry}" does not export a Holo ${label}.`);
+    }
+    items.push(item);
+  }
+  return items;
+}
+async function loadMigrations(entries) {
+  const migrations = await loadRuntimeItems(entries, isMigration, "migration");
+  return migrations.map((migration, index) => normalizeRuntimeMigration(entries[index] ?? "", migration));
+}
+async function loadSeeders(entries) {
+  return loadRuntimeItems(entries, isSeeder, "seeder");
+}
+function printExecutedItems(items, emptyMessage, header) {
+  if (items.length === 0) {
+    writeOutput(emptyMessage);
+    return;
+  }
+  writeOutput(header);
+  for (const item of items) {
+    writeOutput(`  ${item.name}`);
+  }
+}
+function payloadEntries(entries) {
+  return entries ?? [];
+}
+function resolveRuntimeConfig(runtimeConfig) {
+  if (!runtimeConfig) {
+    throw new Error("Runtime payload is missing database configuration.");
+  }
+  return runtimeConfig;
+}
+function writeOutput(message) {
+  process.stdout.write(`${message}
+`);
+}
+var manager = resolveRuntimeConnectionManagerOptions(resolveRuntimeConfig(payload.runtimeConfig));
+configureDB(manager);
+try {
+  await manager.initializeAll();
+  if (payload.kind === "migrate") {
+    await preloadGeneratedSchema(manager, payload.generatedSchema);
+    const migrations = await loadMigrations(payloadEntries(payload.migrations));
+    await hydrateGeneratedSchemaFromRanMigrations(manager, migrations);
+    const executed = await createMigrationService(manager.connection(), migrations).migrate(payload.options ?? {});
+    await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath, payload.generatedSchemaRuntimeOutputPath);
+    printExecutedItems(executed, "No migrations were executed.", "Migrations executed:");
+  } else if (payload.kind === "fresh") {
+    const migrations = await loadMigrations(payloadEntries(payload.migrations));
+    const schema = createSchemaService(manager.connection());
+    await dropAllTablesForFresh(manager.connection(), schema);
+    manager.connection().getSchemaRegistry().clear();
+    const executed = await createMigrationService(manager.connection(), migrations).migrate({});
+    await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath, payload.generatedSchemaRuntimeOutputPath);
+    syncGeneratedSchemaFromManager(manager);
+    printExecutedItems(executed, "No migrations were executed.", "Migrations executed:");
+    if (payload.options?.seed) {
+      const seeded = await createSeederService(manager.connection(), await loadSeeders(payloadEntries(payload.seeders))).seed({
+        ...Array.isArray(payload.options.only) ? { only: payload.options.only } : {},
+        quietly: payload.options.quietly === true,
+        force: payload.options.force === true,
+        environment: typeof payload.options.environment === "string" ? payload.options.environment : "development"
+      });
+      printExecutedItems(seeded, "No seeders were executed.", "Seeders executed:");
+    }
+  } else if (payload.kind === "rollback") {
+    await preloadGeneratedSchema(manager, payload.generatedSchema);
+    const migrations = await loadMigrations(payloadEntries(payload.migrations));
+    await hydrateGeneratedSchemaFromRanMigrations(manager, migrations);
+    const rolledBack = await createMigrationService(manager.connection(), migrations).rollback(payload.options ?? {});
+    await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath, payload.generatedSchemaRuntimeOutputPath);
+    printExecutedItems(rolledBack, "No migrations were rolled back.", "Migrations rolled back:");
+  } else if (payload.kind === "seed") {
+    await preloadGeneratedSchema(manager, payload.generatedSchema);
+    const executed = await createSeederService(manager.connection(), await loadSeeders(payloadEntries(payload.seeders))).seed(payload.options ?? {});
+    printExecutedItems(executed, "No seeders were executed.", "Seeders executed:");
+  } else if (payload.kind === "prune") {
+    const models = await loadRuntimeItems(payloadEntries(payload.models), isModel, "model");
+    const byName = new Map(models.map((model) => [model.definition.name, model]));
+    const requested = Array.isArray(payload.options?.models) ? payload.options.models : [];
+    const selected = [];
+    if (requested.length === 0) {
+      selected.push(...models.filter((model) => Boolean(model.definition.prunable)));
+    } else {
+      for (const name of requested) {
+        if (typeof name !== "string") {
+          console.warn(`Ignoring non-string prunable model name: ${JSON.stringify(name)}`);
+          continue;
+        }
+        const model = byName.get(name);
+        if (!model) {
+          throw new Error(`Unknown model "${name}".`);
+        }
+        if (!model.definition.prunable) {
+          throw new Error(`Model "${name}" does not define a prunable query.`);
+        }
+        selected.push(model);
+      }
+    }
+    if (selected.length === 0) {
+      writeOutput("No prunable models were registered.");
+    } else {
+      let total = 0;
+      for (const model of selected) {
+        const deleted = await model.prune();
+        total += deleted;
+        writeOutput(`${model.definition.name}: deleted ${deleted}`);
+      }
+      writeOutput(`Total deleted: ${total}`);
+    }
+  } else {
+    throw new Error(`Unknown runtime command "${payload.kind}".`);
+  }
+} finally {
+  await manager.disconnectAll();
+  resetDB();
+}

package/dist/{scaffold-UBOS2NZR.mjs → scaffold-DEOTRALR.mjs}

@@ -14,6 +14,7 @@ import {
   installMediaIntoProject,
   installNotificationsIntoProject,
   installQueueIntoProject,
+  installRealtimeIntoProject,
   installSecurityIntoProject,
   normalizeScaffoldEnvSegments,
   publishAuthNotificationsIntoProject,
@@ -55,19 +56,20 @@ import {
   upsertMediaPackageDependency,
   upsertNotificationsPackageDependency,
   upsertSecurityPackageDependency
-} from "./chunk-WRZFATUT.mjs";
-import "./chunk-SRPGIWCF.mjs";
+} from "./chunk-MCVRN7KX.mjs";
+import "./chunk-YEFJBN56.mjs";
 import {
   renderAuthProviderRouteFiles,
   renderFrameworkFiles,
-  renderFrameworkRunner
-} from "./chunk-IMOGEKB4.mjs";
+  renderFrameworkRunner,
+  renderNextBroadcastConfigRoute
+} from "./chunk-J76GH2DR.mjs";
 import {
   isSupportedCacheInstallerDriver,
   isSupportedQueueInstallerDriver,
   normalizeScaffoldOptionalPackages,
   sanitizePackageName
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 export {
   authFeaturesRequireConfigUpdate,
   detectAuthInstallFeaturesFromConfig,
@@ -84,6 +86,7 @@ export {
   installMediaIntoProject,
   installNotificationsIntoProject,
   installQueueIntoProject,
+  installRealtimeIntoProject,
   installSecurityIntoProject,
   isSupportedCacheInstallerDriver,
   isSupportedQueueInstallerDriver,
@@ -104,6 +107,7 @@ export {
   renderMailConfig,
   renderMailEnvFiles,
   renderMediaConfig,
+  renderNextBroadcastConfigRoute,
   renderNotificationsConfig,
   renderNotificationsMigration,
   renderQueueConfig,