@vertz/cli 0.2.12 → 0.2.14

package/dist/vertz.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env bun
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+import {
+  __require,
+  loadDbContext
+} from "./shared/chunk-08ajrqm8.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import { createJiti as createJiti2 } from "jiti";
+import { createJiti } from "jiti";
 
 // src/commands/build.ts
 import { err, ok } from "@vertz/errors";
@@ -53,8 +55,11 @@ import { createCompiler as createCompiler2 } from "@vertz/compiler";
 import * as esbuild from "esbuild";
 
 // src/pipeline/orchestrator.ts
-import { createCompiler, OpenAPIGenerator } from "@vertz/compiler";
-import { generate, createCodegenPipeline } from "@vertz/codegen";
+import { createCodegenPipeline, generate } from "@vertz/codegen";
+import {
+  createCompiler,
+  OpenAPIGenerator
+} from "@vertz/compiler";
 var defaultPipelineConfig = {
   sourceDir: "src",
   outputDir: ".vertz/generated",
@@ -107,6 +112,13 @@ class PipelineOrchestrator {
       if (!analyzeResult.success) {
         success = false;
       }
+      if (success) {
+        const dbSyncResult = await this.runDbSync();
+        stages.push(dbSyncResult);
+        if (!dbSyncResult.success) {
+          success = false;
+        }
+      }
       if (success && this.appIR) {
         const generateResult = await this.runCodegen();
         stages.push(generateResult);
@@ -271,12 +283,60 @@ class PipelineOrchestrator {
   }
   async runDbSync() {
     const startTime = performance.now();
-    return {
-      stage: "db-sync",
-      success: true,
-      durationMs: performance.now() - startTime,
-      output: "DB sync complete (noop for now)"
-    };
+    if (!this.config.autoSyncDb) {
+      return {
+        stage: "db-sync",
+        success: true,
+        durationMs: performance.now() - startTime,
+        output: "DB sync skipped (disabled)"
+      };
+    }
+    let runner;
+    try {
+      if (this.config._dbSyncRunner) {
+        runner = await this.config._dbSyncRunner();
+      } else {
+        const { loadAutoMigrateContext } = await import("./shared/chunk-f6hd0h7q.js");
+        const ctx = await loadAutoMigrateContext();
+        const { autoMigrate } = await import("@vertz/db/internals");
+        runner = {
+          run: () => autoMigrate({
+            currentSchema: ctx.currentSchema,
+            snapshotPath: ctx.snapshotPath,
+            dialect: ctx.dialect,
+            db: ctx.db
+          }),
+          close: ctx.close
+        };
+      }
+    } catch {
+      return {
+        stage: "db-sync",
+        success: true,
+        durationMs: performance.now() - startTime,
+        output: "DB sync skipped (no db config)"
+      };
+    }
+    try {
+      await runner.run();
+      return {
+        stage: "db-sync",
+        success: true,
+        durationMs: performance.now() - startTime,
+        output: "DB sync complete"
+      };
+    } catch (error) {
+      return {
+        stage: "db-sync",
+        success: false,
+        durationMs: performance.now() - startTime,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    } finally {
+      try {
+        await runner.close();
+      } catch {}
+    }
   }
   getAppIR() {
     return this.appIR;
@@ -336,7 +396,7 @@ function getAffectedStages(category) {
     case "entity":
       return ["analyze", "openapi", "codegen"];
     case "schema":
-      return ["codegen", "openapi"];
+      return ["db-sync", "codegen", "openapi"];
     case "component":
       return ["build-ui"];
     case "config":
@@ -346,6 +406,7 @@ function getAffectedStages(category) {
       return ["build-ui"];
   }
 }
+var STAGE_ORDER = ["analyze", "db-sync", "codegen", "openapi", "build-ui"];
 function getStagesForChanges(changes) {
   const stages = new Set;
   for (const change of changes) {
@@ -356,7 +417,7 @@ function getStagesForChanges(changes) {
   if (stages.has("codegen") && !stages.has("analyze")) {
     stages.add("analyze");
   }
-  return Array.from(stages);
+  return STAGE_ORDER.filter((s) => stages.has(s));
 }
 function createWatcher(config) {
   const {
@@ -1588,188 +1649,229 @@ function generateAction(options) {
   }
 }
 
-// src/commands/load-db-context.ts
-import {
-  access,
-  readFile as fsReadFile,
-  writeFile as fsWriteFile,
-  mkdir,
-  readdir
-} from "node:fs/promises";
-import { dirname as dirname2, join as join6, resolve as resolve3 } from "node:path";
-import {
-  createSnapshot,
-  defaultPostgresDialect,
-  defaultSqliteDialect,
-  parseMigrationName
-} from "@vertz/db";
-import { NodeSnapshotStorage } from "@vertz/db/internals";
-import { createJiti } from "jiti";
-var DEFAULT_SQLITE_PATH = "./app.db";
-async function loadDbContext() {
-  const configPath = resolve3(process.cwd(), "vertz.config.ts");
-  const jiti = createJiti(import.meta.url, { interopDefault: true });
-  let configModule;
-  try {
-    configModule = await jiti.import(configPath);
-  } catch {
-    try {
-      await access(configPath);
-    } catch {
-      throw new Error(`Could not find vertz.config.ts in ${process.cwd()}. Create it with a db export:
-
-` + `  export const db = {
-` + `    dialect: 'sqlite',
-` + `    schema: './src/schema.ts',
-` + `  };
-`);
+// src/commands/start.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync } from "node:fs";
+import { join as join6, resolve as resolve3 } from "node:path";
+import { err as err7, ok as ok7 } from "@vertz/errors";
+function discoverSSRModule(projectRoot) {
+  const serverDir = join6(projectRoot, "dist", "server");
+  if (!existsSync6(serverDir))
+    return;
+  const files = readdirSync2(serverDir).filter((f) => f.endsWith(".js"));
+  if (files.length === 0)
+    return;
+  if (files.includes("app.js")) {
+    return join6(serverDir, "app.js");
+  }
+  const first = files[0];
+  return first ? join6(serverDir, first) : undefined;
+}
+function validateBuildOutputs(projectRoot, appType) {
+  const missing = [];
+  if (appType === "api-only" || appType === "full-stack") {
+    const apiBuild = join6(projectRoot, ".vertz", "build", "index.js");
+    if (!existsSync6(apiBuild)) {
+      missing.push(".vertz/build/index.js");
     }
-    throw new Error(`Failed to load vertz.config.ts: the file exists but could not be parsed. Check for syntax errors.`);
   }
-  const dbConfig = configModule.db;
-  if (!dbConfig) {
-    throw new Error(`No \`db\` export found in ${configPath}. Add a named export:
-
-` + `  export const db = {
-` + `    dialect: 'sqlite',
-` + `    schema: './src/schema.ts',
-` + `  };
-`);
+  if (appType === "ui-only" || appType === "full-stack") {
+    const clientHtml = join6(projectRoot, "dist", "client", "index.html");
+    if (!existsSync6(clientHtml)) {
+      missing.push("dist/client/index.html");
+    }
+    const ssrModule = discoverSSRModule(projectRoot);
+    if (!ssrModule) {
+      missing.push("dist/server/ (no SSR module found)");
+    }
   }
-  if (!dbConfig.dialect) {
-    throw new Error('Missing `dialect` in db config (expected "sqlite" or "postgres")');
+  if (missing.length > 0) {
+    return err7(new Error(`Missing build outputs:
+  - ${missing.join(`
+  - `)}
+
+Run "vertz build" first.`));
   }
-  if (!dbConfig.schema) {
-    throw new Error("Missing `schema` in db config (path to schema file)");
+  return ok7(undefined);
+}
+async function startAction(options = {}) {
+  const { port = Number(process.env.PORT) || 3000, host = "0.0.0.0", verbose = false } = options;
+  const projectRoot = findProjectRoot(process.cwd());
+  if (!projectRoot) {
+    return err7(new Error("Could not find project root. Are you in a Vertz project?"));
   }
-  const cwd = process.cwd();
-  const migrationsDir = resolve3(cwd, dbConfig.migrationsDir ?? "./migrations");
-  const snapshotPath = dbConfig.snapshotPath ? resolve3(cwd, dbConfig.snapshotPath) : join6(migrationsDir, "_snapshot.json");
-  const schemaPath = resolve3(cwd, dbConfig.schema);
-  let schemaModule;
+  let detected;
   try {
-    schemaModule = await jiti.import(schemaPath);
-  } catch {
-    try {
-      await access(schemaPath);
-    } catch {
-      throw new Error(`Schema file not found: ${schemaPath}. Check the \`schema\` path in your db config.`);
-    }
-    throw new Error(`Failed to load schema file at ${schemaPath}. Check for syntax errors.`);
+    detected = detectAppType(projectRoot);
+  } catch (error) {
+    return err7(new Error(error instanceof Error ? error.message : String(error)));
   }
-  const tables = extractTables(schemaModule);
-  if (tables.length === 0) {
-    throw new Error(`No table definitions found in ${schemaPath}. Export your tables as named exports:
-
-` + `  export const users = d.table('users', { ... });
-`);
+  if (verbose) {
+    console.log(`Detected app type: ${detected.type}`);
+  }
+  const validation = validateBuildOutputs(projectRoot, detected.type);
+  if (!validation.ok) {
+    return validation;
+  }
+  switch (detected.type) {
+    case "api-only":
+      return startApiOnly(projectRoot, port, host, verbose);
+    case "ui-only":
+      return startUIOnly(projectRoot, port, host, verbose);
+    case "full-stack":
+      return startFullStack(projectRoot, port, host, verbose);
   }
-  const currentSnapshot = createSnapshot(tables);
-  const storage = new NodeSnapshotStorage;
-  const savedSnapshot = await storage.load(snapshotPath);
-  const previousSnapshot = savedSnapshot ?? { version: 1, tables: {}, enums: {} };
-  const dialect = dbConfig.dialect === "sqlite" ? defaultSqliteDialect : defaultPostgresDialect;
-  const connection = await createConnection(dbConfig);
-  const migrationFiles = await loadMigrationFiles(migrationsDir);
-  const existingFiles = migrationFiles.map((f) => f.name);
-  const writeFile = async (path, content) => {
-    await mkdir(dirname2(path), { recursive: true });
-    await fsWriteFile(path, content, "utf-8");
-  };
-  const readFile = (path) => fsReadFile(path, "utf-8");
-  return {
-    queryFn: connection.queryFn,
-    currentSnapshot,
-    previousSnapshot,
-    savedSnapshot: savedSnapshot ?? undefined,
-    migrationFiles,
-    migrationsDir,
-    existingFiles,
-    dialect,
-    writeFile,
-    readFile,
-    close: connection.close
-  };
-}
-function isTableDef(v) {
-  return v !== null && typeof v === "object" && "_name" in v && "_columns" in v && typeof v._columns === "object" && v._columns !== null;
-}
-function extractTables(module) {
-  return Object.values(module).filter(isTableDef);
-}
-function parseSqliteUrl(url) {
-  if (!url)
-    return DEFAULT_SQLITE_PATH;
-  if (!url.startsWith("sqlite:"))
-    return url;
-  const stripped = url.slice("sqlite:".length);
-  if (stripped.startsWith("///"))
-    return stripped.slice(2);
-  if (stripped.startsWith("//"))
-    return stripped.slice(2) || DEFAULT_SQLITE_PATH;
-  return stripped || DEFAULT_SQLITE_PATH;
 }
-async function createConnection(config) {
-  if (config.dialect === "sqlite") {
-    const dbPath = parseSqliteUrl(config.url);
-    let db;
-    try {
-      const { Database } = await import("bun:sqlite");
-      db = new Database(dbPath);
-    } catch (err7) {
-      throw new Error(`Failed to load bun:sqlite. The vertz CLI requires the Bun runtime for SQLite support.
-Run your command with: bun vertz db <command>`, { cause: err7 });
-    }
-    const queryFn2 = async (sql, params) => {
-      const stmt = db.prepare(sql);
-      const rows = stmt.all(...params);
-      return { rows, rowCount: rows.length };
-    };
-    const close2 = async () => {
-      db.close();
-    };
-    return { queryFn: queryFn2, close: close2 };
+async function startApiOnly(projectRoot, port, host, _verbose) {
+  const entryPath = resolve3(projectRoot, ".vertz", "build", "index.js");
+  let mod;
+  try {
+    mod = await import(entryPath);
+  } catch (error) {
+    return err7(new Error(`Failed to import API module: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  const handler = mod.default?.handler;
+  if (typeof handler !== "function") {
+    return err7(new Error("API module must export default with a .handler function."));
   }
-  let client;
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    fetch: handler
+  });
+  console.log(`Vertz API server running at http://${host === "0.0.0.0" ? "localhost" : host}:${server.port}`);
+  setupGracefulShutdown(server);
+  return ok7(undefined);
+}
+async function startUIOnly(projectRoot, port, host, _verbose) {
+  const ssrModulePath = discoverSSRModule(projectRoot);
+  if (!ssrModulePath) {
+    return err7(new Error('No SSR module found in dist/server/. Run "vertz build" first.'));
+  }
+  const templatePath = resolve3(projectRoot, "dist", "client", "index.html");
+  const template = readFileSync(templatePath, "utf-8");
+  let ssrModule;
   try {
-    const pg = (await import("postgres")).default;
-    client = pg(config.url ?? "");
-  } catch (err7) {
-    throw new Error("Failed to load the `postgres` package. Install it in your project:\n  npm install postgres    # or: bun add postgres", { cause: err7 });
-  }
-  const queryFn = async (query, params) => {
-    const result = await client.unsafe(query, params);
-    const rows = Array.from(result);
-    return { rows, rowCount: rows.length };
-  };
-  const close = async () => {
-    await client.end();
-  };
-  return { queryFn, close };
+    ssrModule = await import(ssrModulePath);
+  } catch (error) {
+    return err7(new Error(`Failed to import SSR module: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  const inlineCSS = discoverInlineCSS(projectRoot);
+  const { createSSRHandler } = await import("@vertz/ui-server/ssr");
+  const ssrHandler = createSSRHandler({
+    module: ssrModule,
+    template,
+    inlineCSS
+  });
+  const clientDir = resolve3(projectRoot, "dist", "client");
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+      const staticResponse = serveStaticFile(clientDir, pathname);
+      if (staticResponse)
+        return staticResponse;
+      return ssrHandler(req);
+    }
+  });
+  console.log(`Vertz server running at http://${host === "0.0.0.0" ? "localhost" : host}:${server.port}`);
+  setupGracefulShutdown(server);
+  return ok7(undefined);
 }
-async function loadMigrationFiles(dir) {
-  let entries;
+async function startFullStack(projectRoot, port, host, _verbose) {
+  const apiEntryPath = resolve3(projectRoot, ".vertz", "build", "index.js");
+  let apiMod;
   try {
-    entries = await readdir(dir);
+    apiMod = await import(apiEntryPath);
   } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-  const files = [];
-  for (const filename of entries.filter((f) => f.endsWith(".sql"))) {
-    const parsed = parseMigrationName(filename);
-    if (!parsed)
-      continue;
-    const content = await fsReadFile(join6(dir, filename), "utf-8");
-    files.push({
-      name: parsed.name,
-      sql: content,
-      timestamp: parsed.timestamp
-    });
+    return err7(new Error(`Failed to import API module: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  const apiHandler = apiMod.default?.handler;
+  if (typeof apiHandler !== "function") {
+    return err7(new Error("API module must export default with a .handler function."));
+  }
+  const ssrModulePath = discoverSSRModule(projectRoot);
+  if (!ssrModulePath) {
+    return err7(new Error('No SSR module found in dist/server/. Run "vertz build" first.'));
   }
-  return files.sort((a, b) => a.timestamp - b.timestamp);
+  const templatePath = resolve3(projectRoot, "dist", "client", "index.html");
+  const template = readFileSync(templatePath, "utf-8");
+  let ssrModule;
+  try {
+    ssrModule = await import(ssrModulePath);
+  } catch (error) {
+    return err7(new Error(`Failed to import SSR module: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  const inlineCSS = discoverInlineCSS(projectRoot);
+  const { createSSRHandler } = await import("@vertz/ui-server/ssr");
+  const ssrHandler = createSSRHandler({
+    module: ssrModule,
+    template,
+    inlineCSS
+  });
+  const clientDir = resolve3(projectRoot, "dist", "client");
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+      if (pathname.startsWith("/api")) {
+        return apiHandler(req);
+      }
+      const staticResponse = serveStaticFile(clientDir, pathname);
+      if (staticResponse)
+        return staticResponse;
+      return ssrHandler(req);
+    }
+  });
+  console.log(`Vertz full-stack server running at http://${host === "0.0.0.0" ? "localhost" : host}:${server.port}`);
+  setupGracefulShutdown(server);
+  return ok7(undefined);
+}
+function discoverInlineCSS(projectRoot) {
+  const cssDir = resolve3(projectRoot, "dist", "client", "assets");
+  if (!existsSync6(cssDir))
+    return;
+  const cssFiles = readdirSync2(cssDir).filter((f) => f.endsWith(".css"));
+  if (cssFiles.length === 0)
+    return;
+  const result = {};
+  for (const file of cssFiles) {
+    const content = readFileSync(join6(cssDir, file), "utf-8");
+    result[`/assets/${file}`] = content;
+  }
+  return result;
+}
+function serveStaticFile(clientDir, pathname) {
+  if (pathname === "/" || pathname === "/index.html")
+    return null;
+  const filePath = resolve3(clientDir, `.${pathname}`);
+  if (!filePath.startsWith(clientDir))
+    return null;
+  const file = Bun.file(filePath);
+  if (!file.size)
+    return null;
+  const isHashedAsset = pathname.startsWith("/assets/");
+  const cacheControl = isHashedAsset ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+  return new Response(file, {
+    headers: {
+      "Cache-Control": cacheControl,
+      "Content-Type": file.type
+    }
+  });
+}
+function setupGracefulShutdown(server) {
+  const shutdown = () => {
+    console.log(`
+Shutting down...`);
+    server.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGHUP", shutdown);
 }
 
 // src/cli.ts
@@ -1812,6 +1914,17 @@ function createCLI() {
       process.exit(1);
     }
   });
+  program.command("start").description('Start the production server (run "vertz build" first)').option("-p, --port <port>", "Server port (default: PORT env or 3000)").option("--host <host>", "Server host", "0.0.0.0").option("-v, --verbose", "Verbose output").action(async (opts) => {
+    const result = await startAction({
+      port: opts.port ? parseInt(opts.port, 10) : undefined,
+      host: opts.host,
+      verbose: opts.verbose
+    });
+    if (!result.ok) {
+      console.error(result.error.message);
+      process.exit(1);
+    }
+  });
   program.command("generate [type] [name]").description("Generate a module, service, router, or schema").option("--dry-run", "Preview generated files without writing").option("--source-dir <dir>", "Source directory", "src").allowUnknownOption().action(async (type, name, options) => {
     const validTypes = ["module", "service", "router", "schema"];
     if (!type || !validTypes.includes(type)) {
@@ -1831,13 +1944,13 @@ function createCLI() {
     }
   });
   program.command("codegen").description("Generate SDK and CLI clients from the compiled API").option("--dry-run", "Preview generated files without writing").option("--output <dir>", "Output directory").action(async (opts) => {
-    const { resolve: resolve4, dirname: dirname3 } = await import("node:path");
-    const { mkdir: mkdir2, writeFile: fsWriteFile2 } = await import("node:fs/promises");
+    const { resolve: resolve4, dirname: dirname2 } = await import("node:path");
+    const { mkdir, writeFile: fsWriteFile } = await import("node:fs/promises");
     let config;
     let compilerConfig;
     try {
       const configPath = resolve4(process.cwd(), "vertz.config.ts");
-      const jiti = createJiti2(import.meta.url);
+      const jiti = createJiti(import.meta.url);
       const configModule = await jiti.import(configPath);
       config = configModule.codegen ?? configModule.default?.codegen;
       compilerConfig = configModule.default;
@@ -1861,8 +1974,8 @@ function createCLI() {
     const { createCodegenPipeline: createCodegenPipeline2 } = await import("@vertz/codegen");
     const pipeline = createCodegenPipeline2();
     const writeFile = async (path, content) => {
-      await mkdir2(dirname3(path), { recursive: true });
-      await fsWriteFile2(path, content, "utf-8");
+      await mkdir(dirname2(path), { recursive: true });
+      await fsWriteFile(path, content, "utf-8");
     };
     const result = await codegenAction({
       config,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/cli",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "type": "module",
   "license": "MIT",
   "description": "Vertz CLI — dev, build, create, and deploy commands",
@@ -34,13 +34,13 @@
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json"
   },
   "dependencies": {
-    "@vertz/codegen": "^0.2.11",
-    "@vertz/errors": "^0.2.11",
-    "@vertz/tui": "^0.2.11",
-    "@vertz/compiler": "^0.2.11",
-    "@vertz/create-vertz-app": "^0.2.11",
-    "@vertz/db": "^0.2.11",
-    "@vertz/ui-server": "^0.2.11",
+    "@vertz/codegen": "^0.2.13",
+    "@vertz/errors": "^0.2.13",
+    "@vertz/tui": "^0.2.13",
+    "@vertz/compiler": "^0.2.13",
+    "@vertz/create-vertz-app": "^0.2.13",
+    "@vertz/db": "^0.2.13",
+    "@vertz/ui-server": "^0.2.13",
     "esbuild": "^0.25.0",
     "commander": "^14.0.0",
     "jiti": "^2.4.2"