@webjsdev/cli 0.10.16 → 0.10.18

package/README.md

@@ -40,15 +40,15 @@ Both `webjs create` and `create-webjs-app` auto-install dependencies in the new
 ```sh
 webjs create <name>            # scaffold a full-stack app (default)
 webjs create <name> --template api   # backend-only API app
-webjs create <name> --template saas  # auth + dashboard + Prisma User model
+webjs create <name> --template saas  # auth + dashboard + Drizzle User model
 
-webjs dev                      # dev server with live reload (prefer `npm run dev`, which runs the predev prisma generate hook)
+webjs dev                      # dev server with live reload (runs webjs.dev.before, e.g. webjs db migrate, then serves; npm run dev is a thin alias)
 webjs start                    # production server (no build step, serves source directly)
 webjs check                    # validate source-code conventions (CI gate)
 webjs doctor                   # verify the project/toolchain setup (local onboarding, not CI)
 webjs test                     # run server + browser tests
 webjs vendor pin [--download]  # pin client deps to a committable importmap (offline/reproducible)
-webjs db <prisma-subcommand>   # prisma passthrough (saas template)
+webjs db <generate|migrate|push|studio|seed>   # drizzle-kit passthrough (+ seed)
 
 webjs ui init                  # initialise @webjsdev/ui in this project
 webjs ui add <names...>        # copy components from the registry (https://ui.webjs.dev/registry/<name>.json)

package/bin/webjs.js

@@ -4,6 +4,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { checkNodeInline, nodeInlineMessage } from '../lib/node-preflight.js';
 import { loadAppEnv, resolvePort } from '../lib/port.js';
+import { planDevSupervisor } from '../lib/dev-supervisor.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const [cmd, ...rest] = process.argv.slice(2);
@@ -39,7 +40,8 @@ if (cmd !== 'help' && cmd !== undefined) {
 const TEMPLATES = ['full-stack', 'api', 'saas'];
 
 const USAGE = `webjs commands:
-  webjs dev   [--port 8080]                       Start dev server with live reload
+  webjs dev   [--port 8080] [--no-hot]            Start dev server with live reload
+                                                  (--no-hot: run in-process, no hot-reload supervisor)
   webjs start [--port 8080]                       Start production server (serves source directly, no build step)
   webjs test  [--server|--browser]                 Run server + browser tests
   webjs check [--json]                            Run correctness checks on the app (--json emits structured violations)
@@ -47,13 +49,15 @@ const USAGE = `webjs commands:
   webjs doctor                                    Verify project health (Node, tsconfig, env, vendor pins, importmap coherence, @webjsdev versions, git hook)
   webjs types                                     Generate .webjs/routes.d.ts (typed Route union + per-route params)
   webjs typecheck [tsc args...]                   Type-check the app with the project's tsc --noEmit (non-zero on errors)
-  webjs create <name> [--template full-stack|api|saas] [--no-install]  Scaffold a new webjs app
-                                                  (only 3 templates exist. default: full-stack with Prisma+SQLite)
+  webjs create <name> [--template full-stack|api|saas] [--db sqlite|postgres] [--no-install]  Scaffold a new webjs app
+                                                  (only 3 templates exist. default: full-stack, Drizzle, --db sqlite)
                                                   Auto-runs the detected package manager's install in the new dir
                                                   unless --no-install is passed.
-  webjs db generate                               Run \`prisma generate\`
-  webjs db migrate [name]                         Run \`prisma migrate dev\`
-  webjs db studio                                 Run \`prisma studio\`
+  webjs db generate                               Generate a SQL migration from the schema (drizzle-kit generate)
+  webjs db migrate                                Apply pending migrations (drizzle-kit migrate)
+  webjs db push                                   Push the schema straight to the dev DB (drizzle-kit push)
+  webjs db studio                                 Open the database browser (drizzle-kit studio)
+  webjs db seed                                   Run the app's db/seed.server.ts
   webjs ui <subcmd>                               AI-first component library CLI
                                                   (init / add / list / view / diff / info)
                                                   Requires @webjsdev/ui installed in the project
@@ -71,6 +75,42 @@ function flag(args, name, def) {
   return args[i + 1];
 }
 
+/**
+ * Run the configured `before` steps (#550) for a phase, aborting the boot on
+ * the first failure. The orchestration lives in `lib/run-tasks.js` (pure,
+ * unit-tested); this owns the phase-prefixed logging + the non-zero exit (a
+ * failed generate/migrate must not serve stale code/schema).
+ *
+ * @param {string} phase 'dev' | 'start' (for the log line)
+ * @param {string[]} steps
+ * @param {string} cwd
+ */
+async function runPhaseBeforeSteps(phase, steps, cwd) {
+  const { runBeforeSteps } = await import('../lib/run-tasks.js');
+  const r = await runBeforeSteps(steps, cwd, {
+    onStep: (step) => console.log(`webjs ${phase}: running before-step \`${step}\`…`),
+  });
+  if (!r.ok) {
+    console.error(`webjs ${phase}: before-step failed (exit ${r.code}): ${r.step}`);
+    process.exit(r.code);
+  }
+}
+
+/**
+ * Spawn the configured dev `parallel` tasks (#550) with phase-prefixed logging,
+ * delegating the spawn + teardown to `lib/run-tasks.js`'s `startParallelTasks`.
+ *
+ * @param {string[]} commands
+ * @param {string} cwd
+ * @returns {Promise<() => void>} the killer
+ */
+async function startDevParallelTasks(commands, cwd) {
+  const { startParallelTasks } = await import('../lib/run-tasks.js');
+  return startParallelTasks(commands, cwd, {
+    onStart: (cmd) => console.log(`webjs dev: starting parallel task \`${cmd}\`…`),
+  });
+}
+
 async function main() {
   // Preflight: webjs needs Node 24+ (built-in TS strip + recursive fs.watch).
   // Run before any subcommand so an older Node fails fast with a clear,
@@ -83,7 +123,8 @@ async function main() {
   }
   switch (cmd) {
     case 'dev': {
-      // If we're already inside the --watch child, start the server directly.
+      // If we're already inside the reload child (node --watch or bun --hot),
+      // start the server directly.
       if (process.env.__WEBJS_DEV_CHILD === '1') {
         const { startServer } = await import('@webjsdev/server');
         // Load `.env` BEFORE resolving the port so a `PORT` set there is in
@@ -95,46 +136,46 @@ async function main() {
         break;
       }
 
-      // A bare `webjs dev` (not `npm run dev`) skips the `predev` hook, so a
-      // Prisma app boots against an ungenerated client and crashes with no
-      // hint (#452). Detect that here, in the PARENT only, so the message
-      // prints once rather than on every watch restart. Scoped to Prisma apps;
-      // a non-Prisma app sees nothing. A hint, not an auto-run.
-      const { prismaDevHint } = await import('../lib/prisma-preflight.js');
-      const hint = prismaDevHint(process.cwd());
-      if (hint) console.error(hint);
-
-      // Otherwise, spawn ourselves as a child with node --watch.
-      // This restarts the process on file changes, guaranteeing a fresh
-      // Node ESM module cache. Without this, edits to transitively-imported
-      // modules (actions, queries, components, utils) don't take effect
-      // because Node caches ESM by URL with no public invalidation API.
-      // Build watch paths from directories that exist in the project.
+      // Run the configured dev orchestration in the PARENT only (#550), so a
+      // bare `webjs dev` matches `npm run dev`. `dev.before` (one-shot tasks)
+      // runs to completion first; `dev.parallel` (Tailwind's
+      // watcher, etc.) then runs as children alongside the server. Spawned once
+      // here, NOT in the watch child (which re-execs on every restart). Torn
+      // down on exit so a watcher cannot outlive the server.
+      const { readAppTasks } = await import('../lib/app-tasks.js');
+      const devTasks = readAppTasks(process.cwd());
+      await runPhaseBeforeSteps('dev', devTasks.dev.before, process.cwd());
+      const killTasks = await startDevParallelTasks(devTasks.dev.parallel, process.cwd());
+      process.on('SIGINT', () => { killTasks(); process.exit(0); });
+      process.on('SIGTERM', () => { killTasks(); process.exit(0); });
+
+      // Decide how to run: in-process (`--no-hot`), or re-exec'd under the host
+      // runtime's hot-reload supervisor (`node --watch` on Node, `bun --hot` on
+      // Bun, #514). The branch logic lives in the pure `planDevSupervisor` so it
+      // is unit-testable without spawning a process.
       const { existsSync } = await import('node:fs');
-      const watchPaths = [];
-      for (const dir of ['app', 'components', 'modules', 'lib', 'actions']) {
-        if (existsSync(dir)) watchPaths.push('--watch-path', dir);
-      }
-      // Watch root middleware/config if present
-      for (const f of ['middleware.ts', 'middleware.js']) {
-        if (existsSync(f)) watchPaths.push('--watch-path', f);
+      const plan = planDevSupervisor({
+        isBun: !!process.versions.bun,
+        argv: process.argv.slice(1),
+        noHot: rest.includes('--no-hot'),
+        exists: (p) => existsSync(p),
+      });
+
+      if (plan.mode === 'inline') {
+        const { startServer } = await import('@webjsdev/server');
+        loadAppEnv(process.cwd());
+        const port = resolvePort(flag(rest, '--port'));
+        await startServer({ appDir: process.cwd(), port, dev: true });
+        killTasks();
+        break;
       }
 
-      const child = spawn(
-        process.execPath,
-        [
-          '--watch',
-          '--watch-preserve-output',
-          ...watchPaths,
-          ...process.argv.slice(1),
-        ],
-        {
-          stdio: 'inherit',
-          cwd: process.cwd(),
-          env: { ...process.env, __WEBJS_DEV_CHILD: '1' },
-        },
-      );
-      child.on('exit', (code) => process.exit(code ?? 0));
+      const child = spawn(process.execPath, plan.args, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        env: { ...process.env, __WEBJS_DEV_CHILD: '1' },
+      });
+      child.on('exit', (code) => { killTasks(); process.exit(code ?? 0); });
       break;
     }
     case 'start': {
@@ -142,6 +183,11 @@ async function main() {
       // Load `.env` BEFORE resolving the port so a `PORT` set there wins over
       // the 8080 default (#447), same as for `dev`.
       loadAppEnv(process.cwd());
+      // Run the configured `start.before` steps (e.g. `webjs db migrate`)
+      // before serving (#550), so a bare `webjs start` is not a degraded run
+      // that skips the `prestart` hook. Aborts the boot on a failed step.
+      const { readAppTasks } = await import('../lib/app-tasks.js');
+      await runPhaseBeforeSteps('start', readAppTasks(process.cwd()).start.before, process.cwd());
       const port = resolvePort(flag(rest, '--port'));
       await startServer({ appDir: process.cwd(), port, dev: false });
       break;
@@ -149,10 +195,28 @@ async function main() {
     case 'db': {
       const sub = rest[0];
       const args = rest.slice(1);
-      const map = { generate: ['generate'], migrate: ['migrate', 'dev', ...args], studio: ['studio'] };
-      const prismaArgs = map[sub];
-      if (!prismaArgs) { console.error('Unknown db subcommand.\n' + USAGE); process.exit(1); }
-      const child = spawn('npx', ['prisma', ...prismaArgs], { stdio: 'inherit', cwd: process.cwd() });
+      // `webjs db seed` runs the app's own seed script directly (not a
+      // drizzle-kit command); Drizzle has no codegen, so there is no
+      // `generate`-the-client step, only schema-to-SQL `generate`.
+      if (sub === 'seed') {
+        const { existsSync } = await import('node:fs');
+        const seedFile = ['db/seed.server.ts', 'db/seed.server.js']
+          .map((p) => join(process.cwd(), p)).find(existsSync);
+        if (!seedFile) {
+          console.error('No db/seed.server.ts found in this app.');
+          process.exit(1);
+        }
+        const child = spawn(process.execPath, [seedFile], { stdio: 'inherit', cwd: process.cwd() });
+        child.on('exit', (code) => process.exit(code ?? 0));
+        break;
+      }
+      // generate (schema -> SQL migration), migrate (apply), push (dev
+      // schema sync), studio. All wrap drizzle-kit; the verbose name stays
+      // hidden behind `webjs db`.
+      const map = { generate: ['generate'], migrate: ['migrate'], push: ['push'], studio: ['studio'] };
+      const kitArgs = map[sub];
+      if (!kitArgs) { console.error('Unknown db subcommand.\n' + USAGE); process.exit(1); }
+      const child = spawn('npx', ['drizzle-kit', ...kitArgs, ...args], { stdio: 'inherit', cwd: process.cwd() });
       child.on('exit', (code) => process.exit(code ?? 0));
       break;
     }
@@ -407,18 +471,18 @@ async function main() {
         console.error(`Error: unknown template '${template}'.
 
 Only three scaffolds exist:
-  full-stack   (default): pages + components + API + Prisma/SQLite.
+  full-stack   (default): pages + components + API + Drizzle/SQLite.
                 Pick this for any app the user describes in product terms
                 (todo app, blog, dashboard, marketplace, social feed, …).
   api          backend-only: route handlers + modules, no pages/SSR.
                 Pick this only if the user explicitly asks for an HTTP/JSON
                 API with no UI.
-  saas         auth + login/signup + protected dashboard + Prisma User
+  saas         auth + login/signup + protected dashboard + Drizzle User
                 model. Pick this only if the user explicitly asks for auth
                 or a SaaS-shaped product.
 
 The scaffold is a starting point. Replace the example layout/page/
-components/schema with the actual app the user requested. Use Prisma +
+components/schema with the actual app the user requested. Use Drizzle +
 SQLite for persistence (already wired up). Never store app data in JSON
 files.
 
@@ -426,8 +490,10 @@ Full docs: https://docs.webjs.com`);
         process.exit(1);
       }
       const noInstall = rest.includes('--no-install');
+      // --db picks the database dialect: sqlite (default) or postgres.
+      const db = flag(rest, '--db', 'sqlite');
       const { scaffoldApp } = await import('../lib/create.js');
-      await scaffoldApp(name, process.cwd(), { template, install: !noInstall });
+      await scaffoldApp(name, process.cwd(), { template, db, install: !noInstall });
       break;
     }
     case 'vendor': {

package/lib/app-tasks.js

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Read the dev/start task orchestration from an app's `package.json` `"webjs"`
+ * block (#550). This is what lets `webjs dev` / `webjs start` behave identically
+ * to `npm run dev` / `npm run start`: the orchestration (Tailwind's watcher, a
+ * `db migrate` before prod boot) moves OUT of `concurrently` + `pre*` npm hooks
+ * and INTO the framework primitive, so a bare `webjs dev` is not a degraded run.
+ *
+ * Shape:
+ *   "webjs": {
+ *     "dev":   {
+ *       "before":   ["webjs db migrate"],
+ *       "parallel": ["tailwindcss -i ./public/input.css -o ./public/tailwind.css --watch"]
+ *     },
+ *     "start": { "before": ["webjs db migrate"] }
+ *   }
+ *
+ * `before` commands run sequentially to completion BEFORE the server boots (the
+ * old `predev` / `prestart` hooks: a one-shot `webjs db migrate`).
+ * `parallel` (dev only) commands run as long-lived child processes ALONGSIDE the
+ * server (the old `concurrently` watchers: Tailwind). Returns normalized arrays
+ * (never undefined) so callers iterate without guards, and a missing/empty
+ * config yields empty arrays so a plain app runs `webjs dev`/`start` unchanged.
+ *
+ * Pure (reads one file, never spawns / prints / exits) so it is unit-testable
+ * without a process, matching `lib/port.js` and `lib/dev-supervisor.js`.
+ *
+ * @param {string} appDir
+ * @param {(p: string) => string} [readFile] injectable reader for tests
+ * @returns {{ dev: { before: string[], parallel: string[] }, start: { before: string[] } }}
+ */
+export function readAppTasks(appDir, readFile) {
+  const read = readFile || ((p) => readFileSync(p, 'utf8'));
+  let pkg = {};
+  try {
+    pkg = JSON.parse(read(join(appDir, 'package.json')));
+  } catch {
+    // No package.json, or unparseable: a plain run with no orchestration.
+    return emptyTasks();
+  }
+  const webjs = pkg && typeof pkg === 'object' ? pkg.webjs : null;
+  if (!webjs || typeof webjs !== 'object') return emptyTasks();
+
+  /** Keep only non-empty string entries; drop anything else defensively. */
+  const cmds = (v) =>
+    Array.isArray(v) ? v.filter((s) => typeof s === 'string' && s.trim().length > 0) : [];
+
+  return {
+    dev: {
+      before: cmds(webjs.dev && webjs.dev.before),
+      parallel: cmds(webjs.dev && webjs.dev.parallel),
+    },
+    start: { before: cmds(webjs.start && webjs.start.before) },
+  };
+}
+
+/** @returns {{ dev: { before: string[], parallel: string[] }, start: { before: string[] } }} */
+function emptyTasks() {
+  return { dev: { before: [], parallel: [] }, start: { before: [] } };
+}