@holo-js/cli 0.1.9 → 0.2.1

package/dist/{chunk-HB4Q7VYK.mjs → chunk-KS5TWO75.mjs}

@@ -1,20 +1,21 @@
 import {
   fileExists
-} from "./chunk-57SJ566R.mjs";
+} from "./chunk-LBJAJLKU.mjs";
 import {
   prepareProjectDiscovery
-} from "./chunk-7JR73TOH.mjs";
+} from "./chunk-VP2E62DF.mjs";
 import {
   loadProjectConfig,
   resolveGeneratedSchemaPath
-} from "./chunk-SRPGIWCF.mjs";
+} from "./chunk-YEFJBN56.mjs";
 import {
   loadGeneratedProjectRegistry
-} from "./chunk-IMOGEKB4.mjs";
+} from "./chunk-J76GH2DR.mjs";
 import {
   CLI_RUNTIME_ROOT,
+  GENERATED_SCHEMA_RUNTIME_PATH,
   bundleProjectModule
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/runtime.ts
 import { spawn } from "child_process";
@@ -189,270 +190,6 @@ async function getRuntimeEnvironment(projectRoot) {
     }
   };
 }
-var nodeRuntimeScript = `
-import { mkdir, writeFile } from 'node:fs/promises'
-import { dirname } from 'node:path'
-import {
-  configureDB,
-  createSchemaService,
-  createMigrationService,
-  createSeederService,
-  registerGeneratedTables,
-  renderGeneratedSchemaModule,
-  resetDB,
-  resolveRuntimeConnectionManagerOptions,
-} from '@holo-js/db'
-
-const payload = JSON.parse(process.env.HOLO_RUNTIME_PAYLOAD ?? '{}')
-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 undefined
-}
-
-const isModel = (value) => isRecord(value) && isRecord(value.definition) && value.definition.kind === 'model' && typeof value.prune === 'function'
-const isMigration = (value) => isRecord(value) && typeof value.up === 'function'
-const isSeeder = (value) => isRecord(value) && typeof value.name === 'string' && typeof value.run === 'function'
-const isTable = (value) => isRecord(value) && value.kind === 'table' && typeof value.tableName === 'string' && isRecord(value.columns)
-const RUNTIME_MIGRATION_NAME_PATTERN = ${RUNTIME_MIGRATION_NAME_PATTERN}
-const inferRuntimeMigrationName = ${inferRuntimeMigrationName.toString()}
-const normalizeRuntimeMigration = ${normalizeRuntimeMigration.toString()}
-const compileFreshDropIdentifierPath = ${compileFreshDropIdentifierPath.toString()}
-const dropAllTablesForFresh = ${dropAllTablesForFresh.toString()}
-
-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 []
-}
-
-async function preloadGeneratedSchema(manager, entry) {
-  if (!entry) {
-    return
-  }
-
-  const tables = extractTables(await loadModule(entry))
-  for (const table of tables) {
-    manager.connection().getSchemaRegistry().replace(table)
-  }
-}
-
-async function writeGeneratedSchemaArtifact(manager, outputPath) {
-  if (!outputPath) {
-    return
-  }
-
-  const source = renderGeneratedSchemaModule(manager.connection().getSchemaRegistry().list())
-  await mkdir(dirname(outputPath), { recursive: true })
-  await writeFile(outputPath, source, 'utf8')
-}
-
-function syncGeneratedSchemaFromManager(manager) {
-  registerGeneratedTables(Object.fromEntries(
-    manager.connection().getSchemaRegistry().list().map(table => [table.tableName, table]),
-  ))
-}
-
-const manager = resolveRuntimeConnectionManagerOptions(payload.runtimeConfig)
-configureDB(manager)
-
-try {
-  await manager.initializeAll()
-
-  if (payload.kind === 'migrate') {
-    await preloadGeneratedSchema(manager, payload.generatedSchema)
-    const migrations = []
-    for (const entry of payload.migrations) {
-      const migration = resolveExport(await loadModule(entry), isMigration)
-      if (!migration) {
-        throw new Error(\`Registered migration "\${entry}" does not export a Holo migration.\`)
-      }
-      migrations.push(normalizeRuntimeMigration(entry, migration))
-    }
-
-    const executed = await createMigrationService(manager.connection(), migrations).migrate(payload.options ?? {})
-    await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath)
-    if (executed.length === 0) {
-      console.log('No migrations were executed.')
-    } else {
-      console.log('Migrations executed:')
-      for (const item of executed) {
-        console.log(\`  \${item.name}\`)
-      }
-    }
-  } else if (payload.kind === 'fresh') {
-    const migrations = []
-    for (const entry of payload.migrations) {
-      const migration = resolveExport(await loadModule(entry), isMigration)
-      if (!migration) {
-        throw new Error(\`Registered migration "\${entry}" does not export a Holo migration.\`)
-      }
-      migrations.push(normalizeRuntimeMigration(entry, migration))
-    }
-
-    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)
-    syncGeneratedSchemaFromManager(manager)
-    if (executed.length === 0) {
-      console.log('No migrations were executed.')
-    } else {
-      console.log('Migrations executed:')
-      for (const item of executed) {
-        console.log(\`  \${item.name}\`)
-      }
-    }
-
-    if (payload.options?.seed) {
-      const seeders = []
-      for (const entry of payload.seeders) {
-        const seeder = resolveExport(await loadModule(entry), isSeeder)
-        if (!seeder) {
-          throw new Error(\`Registered seeder "\${entry}" does not export a Holo seeder.\`)
-        }
-        seeders.push(seeder)
-      }
-
-      const seeded = await createSeederService(manager.connection(), seeders).seed({
-        ...(Array.isArray(payload.options.only) ? { only: payload.options.only } : {}),
-        quietly: payload.options.quietly === true,
-        force: payload.options.force === true,
-        environment: payload.options.environment ?? 'development',
-      })
-      if (seeded.length === 0) {
-        console.log('No seeders were executed.')
-      } else {
-        console.log('Seeders executed:')
-        for (const item of seeded) {
-          console.log(\`  \${item.name}\`)
-        }
-      }
-    }
-  } else if (payload.kind === 'rollback') {
-    await preloadGeneratedSchema(manager, payload.generatedSchema)
-    const migrations = []
-    for (const entry of payload.migrations) {
-      const migration = resolveExport(await loadModule(entry), isMigration)
-      if (!migration) {
-        throw new Error(\`Registered migration "\${entry}" does not export a Holo migration.\`)
-      }
-      migrations.push(normalizeRuntimeMigration(entry, migration))
-    }
-
-    const rolledBack = await createMigrationService(manager.connection(), migrations).rollback(payload.options ?? {})
-    await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath)
-    if (rolledBack.length === 0) {
-      console.log('No migrations were rolled back.')
-    } else {
-      console.log('Migrations rolled back:')
-      for (const item of rolledBack) {
-        console.log(\`  \${item.name}\`)
-      }
-    }
-  } else if (payload.kind === 'seed') {
-    if (payload.generatedSchema) {
-      await preloadGeneratedSchema(manager, payload.generatedSchema)
-    }
-
-    const seeders = []
-    for (const entry of payload.seeders) {
-      const seeder = resolveExport(await loadModule(entry), isSeeder)
-      if (!seeder) {
-        throw new Error(\`Registered seeder "\${entry}" does not export a Holo seeder.\`)
-      }
-      seeders.push(seeder)
-    }
-
-    const executed = await createSeederService(manager.connection(), seeders).seed(payload.options ?? {})
-    if (executed.length === 0) {
-      console.log('No seeders were executed.')
-    } else {
-      console.log('Seeders executed:')
-      for (const item of executed) {
-        console.log(\`  \${item.name}\`)
-      }
-    }
-  } else if (payload.kind === 'prune') {
-    const models = []
-    for (const entry of payload.models) {
-      const model = resolveExport(await loadModule(entry), isModel)
-      if (!model) {
-        throw new Error(\`Registered model "\${entry}" does not export a Holo model.\`)
-      }
-      models.push(model)
-    }
-
-    const byName = new Map(models.map(model => [model.definition.name, model]))
-    const requested = payload.options?.models ?? []
-    const selected = []
-
-    if (requested.length === 0) {
-      selected.push(...models.filter(model => Boolean(model.definition.prunable)))
-    } else {
-      for (const name of requested) {
-        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) {
-      console.log('No prunable models were registered.')
-    } else {
-      let total = 0
-      for (const model of selected) {
-        const deleted = await model.prune()
-        total += deleted
-        console.log(\`\${model.definition.name}: deleted \${deleted}\`)
-      }
-      console.log(\`Total deleted: \${total}\`)
-    }
-  } else {
-    throw new Error(\`Unknown runtime command "\${payload.kind}".\`)
-  }
-} finally {
-  await manager.disconnectAll()
-  resetDB()
-}
-`;
 async function resolvePackageRootFromSpecifier(specifier) {
   let current = dirname(fileURLToPath(import.meta.resolve(specifier)));
   while (true) {
@@ -526,10 +263,29 @@ async function cleanupRuntimeDependencyLink(projectRoot) {
     await writeFile(refPath, String(nextReferences), "utf8");
   });
 }
-function createRuntimeInvocation(script) {
+function resolveRuntimeWorkerPath() {
+  const runtimePath = fileURLToPath(import.meta.url);
+  return runtimePath.endsWith("/src/runtime.ts") ? resolve(dirname(runtimePath), "runtime-worker.ts") : resolve(dirname(runtimePath), "runtime-worker.mjs");
+}
+function supportsNodeTypeStripping(version = process.versions.node) {
+  const [major = "0", minor = "0"] = version.split(".");
+  const majorVersion = Number.parseInt(major, 10);
+  const minorVersion = Number.parseInt(minor, 10);
+  return majorVersion > 22 || majorVersion === 22 && minorVersion >= 6;
+}
+function resolveCompiledRuntimeWorkerPath(workerPath) {
+  return resolve(dirname(workerPath), "../dist/runtime-worker.mjs");
+}
+function createRuntimeInvocation(workerPath = resolveRuntimeWorkerPath()) {
+  if (workerPath.endsWith(".ts")) {
+    return {
+      command: "node",
+      args: supportsNodeTypeStripping() ? ["--experimental-strip-types", workerPath] : [resolveCompiledRuntimeWorkerPath(workerPath)]
+    };
+  }
   return {
     command: "node",
-    args: ["--input-type=module", "--eval", script]
+    args: [workerPath]
   };
 }
 function runRuntimeInvocation(command, args, options) {
@@ -622,9 +378,10 @@ async function withRuntimeEnvironment(projectRoot, kind, options, callback) {
       seeders: environment.bundledSeeders.map((entry) => pathToFileURL(entry).href),
       generatedSchema: environment.bundledGeneratedSchema ? pathToFileURL(environment.bundledGeneratedSchema).href : void 0,
       generatedSchemaOutputPath: resolveGeneratedSchemaPath(projectRoot, environment.project.config),
+      generatedSchemaRuntimeOutputPath: resolve(projectRoot, GENERATED_SCHEMA_RUNTIME_PATH),
       options
     });
-    const runtime = createRuntimeInvocation(nodeRuntimeScript);
+    const runtime = createRuntimeInvocation();
     const result = await runRuntimeInvocation(runtime.command, runtime.args, {
       cwd: runtimeRoot,
       env: {
@@ -660,10 +417,10 @@ export {
   compileFreshDropIdentifierPath,
   dropAllTablesForFresh,
   getRuntimeEnvironment,
-  nodeRuntimeScript,
   resolvePackageRootFromSpecifier,
   ensureRuntimeDependencyLink,
   cleanupRuntimeDependencyLink,
+  resolveRuntimeWorkerPath,
   createRuntimeInvocation,
   runRuntimeInvocation,
   getRuntimeFailureMessage,

package/dist/{chunk-57SJ566R.mjs → chunk-LBJAJLKU.mjs}

@@ -1,6 +1,6 @@
 import {
   readTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/fs-utils.ts
 import { stat } from "fs/promises";

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

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