@webjsdev/cli 0.10.28 → 0.10.29

package/bin/webjs.js

@@ -147,6 +147,12 @@ async function main() {
       // down on exit so a watcher cannot outlive the server.
       const { readAppTasks } = await import('../lib/app-tasks.js');
       const devTasks = readAppTasks(process.cwd());
+      // Load `.env` BEFORE the before-steps (same as `start`, L188), so a
+      // `dev.before` `webjs db migrate` sees DATABASE_URL from `.env`. Without
+      // this a Postgres dev migrate runs with no connection string and fails
+      // (sqlite survives via its `?? 'db/dev.db'` config fallback). The watch
+      // child / inline server load `.env` again later (idempotent).
+      loadAppEnv(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); });

package/lib/create.js

@@ -314,9 +314,9 @@ export async function scaffoldApp(name, cwd, opts = {}) {
     },
     scripts: {
       // No `predev` / `prestart` hooks (#550): the `webjs` block below holds
-      // the start orchestration (`webjs db migrate`), run INSIDE `webjs start`,
-      // so `npm run start` (a thin alias) behaves identically. Drizzle has no
-      // codegen, so there is no dev `before` step.
+      // the dev + start orchestration (`webjs db migrate`), run INSIDE `webjs
+      // dev` / `webjs start`, so `npm run dev` / `start` (thin aliases) behave
+      // identically. Both apply pending migrations before serving (#725).
       //
       // Bun runtime (#541): the long-running server scripts (`dev` / `start`)
       // are prefixed `bun --bun` so the app SERVES on Bun. The `--bun` overrides
@@ -386,16 +386,16 @@ export async function scaffoldApp(name, cwd, opts = {}) {
       // into components/ui/ (they import @webjsdev/core, not the kit), and the
       // CLI resolves @webjsdev/ui from its own install.
     },
-    // Start task orchestration (#550). `webjs start` reads `start.before` and
-    // runs it in-process, so `npm run start` (a thin alias above) behaves
-    // identically. Drizzle has no codegen, so there is no dev `before` step;
-    // production applies pending migrations via `webjs db migrate`. The scaffold
+    // Dev + start task orchestration (#550). `webjs dev` / `webjs start` read
+    // `before` and run it in-process, so `npm run dev` / `start` (thin aliases
+    // above) behave identically. Both apply pending migrations via `webjs db
+    // migrate` (idempotent, a no-op when the db is current), so a freshly
+    // generated migration is applied without a manual step (#725). The scaffold
     // uses the Tailwind browser runtime (no CSS build step), so there is no dev
     // `parallel` watcher here; an app that adds the Tailwind CLI puts its
     // `--watch` command under `webjs.dev.parallel`.
     webjs: {
-      // Drizzle has no codegen, so there is no dev `before` step. Production
-      // applies pending migrations at boot via `webjs db migrate` (drizzle-kit).
+      dev: { before: ['webjs db migrate'] },
       start: { before: ['webjs db migrate'] },
     },
   }, null, 2) + '\n');
@@ -1388,13 +1388,22 @@ For AI agents, read this before editing scaffolded files:
   // Single copy-paste line so the user can move from "scaffold done"
   // to "dev server up" in one command. The full-stack and saas
   // templates ship with @webjsdev/ui already initialised; the api
-  // template has no UI but may add one later. Saas needs a one-time
-  // generate + migrate before the first run (the example User model wants
-  // its table to exist). Drizzle splits Prisma's `migrate dev` into
-  // `db:generate` (schema to SQL) then `db:migrate` (apply).
+  // template has no UI but may add one later.
   const installSegment = installed ? '' : `${pm} install && `;
-  const dbSegment = isSaas ? `${pm} run db:generate && ${pm} run db:migrate && ` : '';
+  // The saas example queries the users table on its first request (auth), so it
+  // needs a migration authored first: `db:generate` writes it and the
+  // `webjs.dev.before` migrate applies it on `run dev` (Drizzle splits Prisma's
+  // `migrate dev` into generate-then-migrate). The full-stack / api examples do
+  // not query the db on first paint, so they boot with just `run dev`; once you
+  // add a db route, `db:generate` then `run dev` is the loop (dev auto-migrates).
+  const dbSegment = isSaas ? `${pm} run db:generate && ` : '';
   const runCommand = `cd ${name} && ${installSegment}${dbSegment}${pm} run dev`;
+  // Postgres needs a reachable DATABASE_URL before any migrate (sqlite uses a
+  // local file with no .env). Point it at a running database; `dev` / `start`
+  // then apply pending migrations via webjs.*.before.
+  const pgNote = dialect === 'postgres'
+    ? `\nPostgres: copy .env.example to .env and set DATABASE_URL to a running database before \`${pm} run dev\`.\n`
+    : '';
   // Use `npx webjsdev ui ...` here, not `npx webjs ui ...`. The bare
   // `webjs` npm name is owned by an unrelated package; `npx webjs
   // <cmd>` would fetch THAT package instead of ours when run outside
@@ -1410,7 +1419,7 @@ For AI agents, read this before editing scaffolded files:
 Next steps:
   ${runCommand}
   # → http://localhost:8080
-
+${pgNote}
 Optional:
   ${uiNote}
 `);

package/lib/saas-template.js

@@ -186,9 +186,10 @@ export async function writeSaasFiles(appDir, opts = {}) {
   //     ALWAYS once the app modules import: auth() only reads a cookie, no DB
   //     query. This is the headline security assertion and it is REAL.
   //   The signup, login, and protected-route flow writes + reads a user, so it
-  //   needs the DB migrated (`npm run db:generate` then `npm run db:migrate`).
-  //   Until the users table exists those flows error, so the suite skips with a
-  //   clear message instead of crashing. After DB setup it runs for real.
+  //   needs the migrated users table (`npm run db:generate`, then `npm run dev`
+  //   applies it via webjs.dev.before). Until then those flows error, so the
+  //   suite probes readiness and skips with a clear message instead of crashing,
+  //   then runs for real once the db is set up.
   await mkdir(join(appDir, 'test', 'auth'), { recursive: true });
   // The generated comments reference `npm run db:*` setup; bun-ify them so a
   // bun-flavored saas app reads `bun run db:*` (#541; db is Node tooling, so a
@@ -205,12 +206,11 @@ export async function writeSaasFiles(appDir, opts = {}) {
     "const appDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');",
     "",
     "// The auth pages + dashboard middleware query the users table via Drizzle.",
-    "// Until `npm run db:generate` + `npm run db:migrate` have created it, a",
-    "// request hitting those modules 500s. We detect that at the RESPONSE level",
+    "// Until `npm run db:generate` has authored the migration (then `npm run dev`",
+    "// applies it via webjs.dev.before, or `npm run db:migrate` directly), a",
+    "// request hitting those modules 500s; we detect that at the RESPONSE level",
     "// (a 5xx on the dashboard) and SKIP with a clear message rather than report",
-    "// a misleading failure. After you run",
-    "//   npm install && npm run db:generate && npm run db:migrate",
-    "// every assertion below runs for real.",
+    "// a misleading failure. After the db is set up every assertion runs for real.",
     "process.env.DATABASE_URL ||= 'file:./dev.db';",
     "process.env.AUTH_SECRET ||= 'test-secret-at-least-32-characters-long!!';",
     "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/cli",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "type": "module",
   "description": "webjs CLI - dev, start, create, db",
   "bin": {

package/templates/AGENTS.md

@@ -329,7 +329,7 @@ db/
   columns.server.ts      column helpers (dialect-specific; the only file to swap for Postgres)
   connection.server.ts   opens the driver, exports the \`db\` singleton (import \`db\` from here)
   seed.server.ts         optional seed (run via \`webjs db seed\`)
-  dev.db                 SQLite file (gitignored); run \`npm run db:migrate\` to create
+  dev.db                 SQLite file (gitignored); created when migrations apply (\`dev\`/\`start\` run \`webjs db migrate\`)
   migrations/            generated migration SQL (committed)
 drizzle.config.ts        drizzle-kit config (root; SQLite by default, --db postgres to switch)
 public/                  static assets, served at /public/*
@@ -387,13 +387,16 @@ lives in the `webjs` block of `package.json` and runs INSIDE
 
 ```jsonc
 "webjs": {
+  "dev": { "before": ["webjs db migrate"] },
   "start": { "before": ["webjs db migrate"] }
 }
 ```
 
-Drizzle has no codegen, so there is no dev `before` step. An app that
-adds the Tailwind CLI puts its `--watch` command under
-`webjs.dev.parallel` and it runs alongside the server, torn down on exit.
+Both `dev` and `start` apply pending migrations via `webjs db migrate`
+(idempotent, a no-op when the db is current), so a freshly generated
+migration is applied without a manual step. An app that adds the Tailwind
+CLI puts its `--watch` command under `webjs.dev.parallel` and it runs
+alongside the server, torn down on exit.
 `before` steps run to completion first; a failed `webjs db migrate`
 aborts the boot with a clear message rather than serving a stale schema.
 
@@ -457,7 +460,7 @@ Scripts (all wrap `drizzle-kit`):
 - `npm run db:push`: `webjs db push` (push the schema straight to the dev DB)
 - `npm run db:studio`: `webjs db studio` (visual DB browser)
 - `npm run db:seed`: `webjs db seed` (run `db/seed.server.ts`)
-- `webjs.start.before` runs `webjs db migrate` inside `webjs start` (idempotent; replaces the old `prestart` hook). No dev `before` step (no codegen).
+- `webjs.dev.before` and `webjs.start.before` both run `webjs db migrate` inside `webjs dev` / `webjs start` (idempotent; replaces the old `prestart` hook), so after you `db:generate` a migration it is applied on the next boot with no manual `db:migrate` step.
 
 Always import `db` from `db/connection.server.ts` (the globalThis-cached
 singleton avoids opening a new connection on every dev-server reload), and

package/templates/CONVENTIONS.md

@@ -268,11 +268,12 @@ docs". That is the agent's default behavior in a webjs project.
 
 Every webjs app uses **Drizzle + SQLite** for persistence by default. The
 scaffold ships the `db/` folder (`schema.server.ts`, `columns.server.ts`,
-`connection.server.ts`), the `webjs.start.before` step that runs
-`webjs db migrate` inside `webjs start` (#550), and the
+`connection.server.ts`), the `webjs.dev.before` + `webjs.start.before` steps
+that run `webjs db migrate` inside `webjs dev` / `webjs start` (#550), and the
 `npm run db:generate` / `db:migrate` / `db:push` / `db:studio` / `db:seed`
-scripts (which route through `webjs db` to drizzle-kit). Drizzle has no
-codegen, so there is no dev `before` step.
+scripts (which route through `webjs db` to drizzle-kit). The loop after a
+schema change is `db:generate` (authors the migration) then `webjs dev` (the
+`dev.before` step applies it); `db:generate` is never auto-run on boot.
 
 **AI agents: these rules are absolute.**