tina4-nodejs 3.13.64 → 3.13.66

package/packages/cli/src/commands/generate.ts

@@ -215,16 +215,51 @@ function isoNow(): string {
   return new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
 }
 
-const GENERATORS =
-  "model, route, crud, migration, middleware, test, form, view, auth, " +
-  "service, queue, validator, seeder, websocket, listener";
+// ── Generator registry — the single source of truth ─────────────────
+//
+// One entry per generator drives `generate` dispatch (below), the human help
+// (`bin.ts` Generators section), AND the `commands --json` manifest's
+// `generate.subcommands`. Add a generator in ONE place and it appears in
+// dispatch, help, and discovery with no second list to keep in sync.
+//
+// Every handler is normalised to `(name, flags) => void`; `auth` takes no name
+// so it drops it. Mirrors the Python master's GENERATORS registry
+// (tina4_python/cli/__init__.py).
+
+export interface GeneratorSpec {
+  handler: (name: string, flags: Record<string, string | boolean>) => void;
+  /** Arg/flag hint shown in `tina4nodejs help` (human only). */
+  usage: string;
+  summary: string;
+}
+
+export const GENERATORS: Record<string, GeneratorSpec> = {
+  model:      { handler: generateModel,                     usage: '<Name> [--fields "name:string,price:float"]', summary: "ORM model + matching migration" },
+  route:      { handler: generateRoute,                     usage: "<name> [--model Name] [--public]",            summary: "CRUD route file, secure by default (--public opens writes)" },
+  crud:       { handler: generateCrud,                      usage: '<Name> [--fields "..."] [--public]',          summary: "Model + migration + routes + form + view + test" },
+  migration:  { handler: (n, f) => generateMigration(n, f), usage: "<description>",                                summary: "Timestamped migration file (UP/DOWN)" },
+  middleware: { handler: generateMiddleware,                usage: "<Name>",                                       summary: "Middleware with before/after hooks" },
+  test:       { handler: generateTest,                      usage: "<name> [--model Name]",                        summary: "Test file" },
+  form:       { handler: generateForm,                      usage: '<Name> [--fields "..."]',                      summary: "Form template with inputs matching model fields" },
+  view:       { handler: generateView,                      usage: '<Name> [--fields "..."]',                      summary: "List + detail view templates" },
+  auth:       { handler: (_n, f) => generateAuth(f),        usage: "",                                             summary: "Login/register routes (public) + User model + templates" },
+  service:    { handler: generateService,                   usage: '<Name> [--every 5m | --cron "..."]',           summary: "Scheduled ServiceRunner task (src/services/)" },
+  queue:      { handler: generateQueue,                     usage: "<topic>",                                      summary: "Producer + consumer daemon worker (src/services/)" },
+  validator:  { handler: generateValidator,                 usage: "<Name>",                                       summary: "Request-body Validator (src/validators/)" },
+  seeder:     { handler: generateSeeder,                    usage: "<Model>",                                      summary: "FakeData + seedOrm seeder (src/seeds/)" },
+  websocket:  { handler: generateWebsocket,                 usage: "<path>",                                       summary: "websocket() handler (src/routes/)" },
+  listener:   { handler: generateListener,                  usage: "<event>",                                      summary: "Events.on(event) listener (src/listeners/)" },
+};
+
+/** Comma-separated generator names for usage/error output — derived, never a hand-kept list. */
+const GENERATOR_LIST = Object.keys(GENERATORS).join(", ");
 
 // ── Main entry point ────────────────────────────────────────────────
 
 export async function generate(what: string, name: string, extraArgs: string[] = []): Promise<void> {
   if (!what) {
     console.error("  Usage: tina4nodejs generate <what> <name> [options]");
-    console.error(`  Generators: ${GENERATORS}`);
+    console.error(`  Generators: ${GENERATOR_LIST}`);
     console.error('  Options:    --fields "name:string,price:float"  --model ModelName');
     console.error("              --public                 open a route's writes (default: secure)");
     console.error('              --every 5m | --cron "…"   service schedule');
@@ -240,62 +275,21 @@ export async function generate(what: string, name: string, extraArgs: string[] =
 
   const { flags } = parseCliArgs(extraArgs);
 
-  switch (what) {
-    case "model":
-      generateModel(name, flags);
-      break;
-    case "route":
-      generateRoute(name, flags);
-      break;
-    case "crud":
-      generateCrud(name, flags);
-      break;
-    case "migration":
-      generateMigration(name, flags);
-      break;
-    case "middleware":
-      generateMiddleware(name, flags);
-      break;
-    case "test":
-      generateTest(name, flags);
-      break;
-    case "form":
-      generateForm(name, flags);
-      break;
-    case "view":
-      generateView(name, flags);
-      break;
-    case "auth":
-      generateAuth(flags);
-      break;
-    case "service":
-      generateService(name, flags);
-      break;
-    case "queue":
-      generateQueue(name, flags);
-      break;
-    case "validator":
-      generateValidator(name, flags);
-      break;
-    case "seeder":
-      generateSeeder(name, flags);
-      break;
-    case "websocket":
-      generateWebsocket(name, flags);
-      break;
-    case "listener":
-      generateListener(name, flags);
-      break;
-    default:
-      console.error(`  Unknown generator: ${what}`);
-      console.error(`  Available: ${GENERATORS}`);
-      process.exit(1);
+  // Dispatch from the single-source-of-truth GENERATORS registry (also feeds
+  // `bin.ts` help + the `commands --json` manifest subcommands).
+  const spec = GENERATORS[what];
+  if (spec) {
+    spec.handler(name, flags);
+  } else {
+    console.error(`  Unknown generator: ${what}`);
+    console.error(`  Available: ${GENERATOR_LIST}`);
+    process.exit(1);
   }
 }
 
 // ── Model ───────────────────────────────────────────────────────────
 
-function generateModel(name: string, flags: Record<string, string | boolean>): void {
+function generateModel(name: string, flags: Record<string, string | boolean>, emitTest = true): void {
   const fields = parseFields((flags.fields as string) || "");
   const table = toTableName(name);
   const dir = resolve("src/models");
@@ -330,10 +324,16 @@ ${fieldLines.join("\n")}
 
   writeFileSafe(path, content);
 
-  // Generate matching migration unless --no-migration
+  // Generate matching migration unless --no-migration. The model's own test
+  // (below) proves the schema through the real ORM, so the migration sub-call
+  // does NOT also co-emit a migration test (emitTest=false).
   if (!flags["no-migration"]) {
-    generateMigration(`create_${table}`, flags, fields.length > 0 ? fields : undefined, table);
+    generateMigration(`create_${table}`, flags, fields.length > 0 ? fields : undefined, table, false);
   }
+
+  // Co-emit a real SQLite roundtrip test next to the model. Composite
+  // generators (crud/auth) pass emitTest=false and emit their own broader test.
+  if (emitTest) emitModelTest(name, table, fields);
 }
 
 // ── Route ───────────────────────────────────────────────────────────
@@ -348,7 +348,7 @@ function secureOptOut(isPublic: boolean): string {
   return isPublic ? `export const secure = false;\n\n` : "";
 }
 
-function generateRoute(name: string, flags: Record<string, string | boolean>): void {
+function generateRoute(name: string, flags: Record<string, string | boolean>, emitTest = true): void {
   const routePath = name.replace(/^\//, "");
   const singular = routePath.endsWith("s") ? routePath.slice(0, -1) : routePath;
   const model = flags.model as string | undefined;
@@ -565,6 +565,18 @@ ${aiFill(`delete_${singular}`, {
 `,
     );
   }
+
+  // Co-emit a real test. A --model route is working code → the secure-by-default
+  // gate test (reads public, writes gated, or open under --public). A no-model
+  // route's handlers are loud AI-FILL stubs → the Router-registration + live-stub
+  // test. Composite generators (crud) pass emitTest=false and emit their own.
+  if (emitTest) {
+    if (model) {
+      generateTest(routePath, { model, "secure-writes": true, public: isPublic });
+    } else {
+      emitRouteStubTest(routePath);
+    }
+  }
 }
 
 // ── CRUD ────────────────────────────────────────────────────────────
@@ -576,12 +588,14 @@ function generateCrud(name: string, flags: Record<string, string | boolean>): vo
 
   console.log(`\n  Generating CRUD for ${name}...\n`);
 
-  // 1. Model + migration
-  generateModel(name, flags);
+  // 1. Model + migration (its own model test is suppressed — the gate test
+  //    below is CRUD's single, broader co-emitted test).
+  generateModel(name, flags, false);
 
   // 2. Routes with model — secure by default; thread --public through so
   //    `generate crud X --public` opens the writes (mirrors AutoCrud public).
-  generateRoute(routeName, { ...flags, model: name });
+  //    Route test suppressed (the gate test below covers the routes).
+  generateRoute(routeName, { ...flags, model: name }, false);
 
   // 3. Form
   generateForm(name, flags);
@@ -604,6 +618,7 @@ function generateMigration(
   flags: Record<string, string | boolean>,
   fieldsOverride?: Array<[string, string]>,
   tableOverride?: string,
+  emitTest = true,
 ): void {
   const ts = timestamp();
   const dir = resolve("migrations");
@@ -664,6 +679,11 @@ function generateMigration(
     `${downSql}\n`;
 
   writeFileSafe(downPath, downContent);
+
+  // Co-emit a real up/down migration test — only for CREATE migrations (a
+  // placeholder ALTER migration has no asserted schema yet). Suppressed when a
+  // model generates its matching migration (the model's own test covers schema).
+  if (emitTest && isCreate) emitMigrationTest(name, table);
 }
 
 // ── Middleware ───────────────────────────────────────────────────────
@@ -707,6 +727,7 @@ export async function after${name}(
 `;
 
   writeFileSafe(path, content);
+  emitMiddlewareTest(name, snake);
 }
 
 // ── Test ────────────────────────────────────────────────────────────
@@ -1004,8 +1025,9 @@ function generateView(name: string, flags: Record<string, string | boolean>): vo
 function generateAuth(_flags: Record<string, string | boolean>): void {
   console.log("\n  Generating authentication scaffolding...\n");
 
-  // 1. User model + migration
-  generateModel("User", { fields: "email:string,password:string,role:string" });
+  // 1. User model + migration (model test suppressed — the auth test below is
+  //    the composite, broader co-emitted test).
+  generateModel("User", { fields: "email:string,password:string,role:string" }, false);
 
   // 2. Auth routes (file-based). register + login are genuinely public — the
   //    user has no token yet — so they opt out of the write gate with
@@ -1158,8 +1180,8 @@ export default async function (req: Tina4Request, res: Tina4Response) {
 `,
   );
 
-  // 5. Auth test
-  generateTest("auth", { model: "User" });
+  // 5. Auth test — real register / login / me end-to-end (no mocks).
+  emitAuthTest();
 
   console.log("\n  Authentication scaffolding complete.");
   console.log("  Run: tina4nodejs migrate");
@@ -1228,6 +1250,7 @@ ${scheduleField}
 `;
 
   writeFileSafe(path, content);
+  emitServiceTest(name, snake, camel);
 }
 
 // ── Queue (producer + consumer worker) ──────────────────────────────
@@ -1288,15 +1311,20 @@ export async function consume${pascal}(_context?: ServiceContext): Promise<void>
 }
 
 // Discovered by ServiceRunner.discover("src/services"); daemon:true because
-// consume${pascal} owns its own loop.
+// consume${pascal} owns its own loop. The topic + per-job handle keys let
+// \`tina4nodejs queue work ${topic}\` drive this consumer directly (own the poll
+// loop / bounded --once drain) without wiring a ServiceRunner.
 export default {
   name: "${topic}-consumer",
+  topic: "${topic}",
   handler: consume${pascal},
+  handle: handle${pascal},
   daemon: true,
 };
 `;
 
   writeFileSafe(path, content);
+  emitQueueTest(topic, slug, pascal);
 }
 
 // ── Validator (request-body Validator) ──────────────────────────────
@@ -1309,14 +1337,13 @@ function generateValidator(name: string, _flags: Record<string, string | boolean
   ensureDir(dir);
   const path = join(dir, `${toSnake(name)}.ts`);
 
-  const body = aiFill(`validate${toPascal(name)}`, {
-    intent: `declare the validation rules for a ${name} payload`,
-    given: "validator -> Validator(data) (chainable)",
-    use: `validator.required("name").email("email").minLength("name", 2).integer("age")`,
-    ret: "the same validator (caller checks .isValid() / .errors())",
-    ground: `tina4_context("validate request body with Validator", "nodejs") · skill tina4-developer-nodejs`,
-    raise: `validator ${toSnake(name)} not implemented`,
-  });
+  // Working-default: ship a real starter rule (required "name") so the
+  // co-emitted valid/invalid test is GREEN on generation — a scaffolded test
+  // that fails on creation is bad DX. Extend the rules for your own payload.
+  const rules = extend(
+    "add / adjust the validation rules for this payload",
+    `e.g. .email("email").minLength("name", 2).integer("age"); ground: tina4_context("validate request body with Validator", "nodejs")`,
+  );
 
   const content = `import { Validator } from "tina4-nodejs";
 
@@ -1329,11 +1356,13 @@ function generateValidator(name: string, _flags: Record<string, string | boolean
  */
 export function validate${toPascal(name)}(data: Record<string, unknown>): Validator {
   const validator = new Validator(data);
-${body}  return validator;
+${rules}  validator.required("name");   // starter rule (matches the model's default field)
+  return validator;
 }
 `;
 
   writeFileSafe(path, content);
+  emitValidatorTest(name, toSnake(name), toPascal(name));
 }
 
 // ── Seeder (FakeData + seedOrm) ─────────────────────────────────────
@@ -1348,14 +1377,13 @@ function generateSeeder(name: string, _flags: Record<string, string | boolean>):
   ensureDir(dir);
   const path = join(dir, `${table}_seeder.ts`);
 
-  const body = aiFill("fieldOverrides", {
-    intent: `map ${name} fields to fake-data generators (only those needing a specific shape)`,
-    given: "fake -> FakeData instance",
-    use: "fake.email() / fake.name() / fake.integer(1, 99) / fake.company()",
-    ret: `{ email: (f) => f.email(), status: "active" }  (Record<string, unknown>)`,
-    ground: `tina4_context("seed ORM model with FakeData", "nodejs") · skill tina4-developer-nodejs`,
-    raise: `seeder ${name} overrides not implemented`,
-  });
+  // Working-default: return {} so seedOrm auto-fills every field by type/name
+  // and the co-emitted rows-created test is GREEN on generation. Override the
+  // fields that need a specific shape below.
+  const overrides = extend(
+    "override fields that need a specific shape (seedOrm auto-fills the rest)",
+    `e.g. return { email: (f) => f.email(), status: "active" }; ground: tina4_context("seed ORM model with FakeData", "nodejs")`,
+  );
 
   const content = `import { pathToFileURL } from "node:url";
 import { FakeData, seedOrm, initDatabase } from "tina4-nodejs/orm";
@@ -1368,7 +1396,9 @@ import ${name} from "../models/${name}.js";
  * specific shape below. Each callable receives a FakeData instance.
  */
 export function fieldOverrides(fake: FakeData): Record<string, unknown> {
-${body}}
+${overrides}  void fake;   // available for overrides above
+  return {};
+}
 
 /** Seed rows. Invoked when this file is run directly by \`tina4nodejs seed\`. */
 export async function run(): Promise<void> {
@@ -1385,6 +1415,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
 `;
 
   writeFileSafe(path, content);
+  emitSeederTest(name, table);
 }
 
 // ── WebSocket route ─────────────────────────────────────────────────
@@ -1446,6 +1477,7 @@ websocket("${wsPath}", ${handlerName});
 `;
 
   writeFileSafe(path, content);
+  emitWebsocketTest(wsPath, base, handlerName);
 }
 
 // ── Event listener ──────────────────────────────────────────────────
@@ -1489,4 +1521,440 @@ Events.on("${event}", ${handlerName});
 `;
 
   writeFileSafe(path, content);
+  emitListenerTest(event, slug);
+}
+
+// ══════════════════════════════════════════════════════════════════════
+// Co-emitted test builders — every code-producing generator emits a REAL,
+// green, no-mock `*.test.ts` next to its scaffold (self-describing CLI epic,
+// Phase 4). Mirrors the Python master's `_write_test` + `_emit_*_test` builders
+// (tina4_python/cli/__init__.py): ONE shared writer + ONE focused builder per
+// generator (not copy-pasted blobs). Each exercises a DIFFERENT real subsystem
+// (real SQLite / TestClient / Router / MiddlewareChain / ServiceRunner / Queue /
+// event bus). CRUD-shaped scaffolds (working code) get behavioural tests;
+// logic-shaped scaffolds (loud AI-FILL stubs) get real wiring tests + a lock-in
+// that the placeholder fails loud. form/view are template-only → exempt (no
+// test); `test` itself is exempt (it IS the test generator).
+// ══════════════════════════════════════════════════════════════════════
+
+/**
+ * The SINGLE place a co-emitted test is written — `tests/<name>.test.ts`
+ * (Node's `*.test.ts` convention, discovered by `tsx test/run-all.ts`). Shares
+ * writeFileSafe's overwrite-refusal + the same "Created …" line every generator
+ * prints. Generalized from generateTest so builders share one rule.
+ */
+function writeTest(testName: string, content: string): void {
+  const dir = resolve("tests");
+  ensureDir(dir);
+  writeFileSafe(join(dir, `${testName}.test.ts`), content);
+}
+
+/**
+ * Assemble a standalone-tsx test: doc header + shared pass/fail tally + body +
+ * summary line + `process.exit`. This is the project's test convention (each
+ * file self-tallies and exits), so `tsx test/run-all.ts` — and the co-emit
+ * meta-test — pick the emitted file up and read its "Results: N passed, M
+ * failed" line. Grounded on the existing secure-gate CRUD test format.
+ */
+function standaloneTest(doc: string, body: string): string {
+  return `${doc}
+
+let pass = 0;
+let fail = 0;
+function assert(label: string, ok: boolean): void {
+  if (ok) { pass++; console.log(\`  PASS \${label}\`); }
+  else { fail++; console.log(\`  FAIL \${label}\`); }
+}
+async function assertThrows(label: string, fn: () => unknown | Promise<unknown>): Promise<void> {
+  try { await fn(); assert(label, false); }
+  catch { assert(label, true); }
+}
+
+${body}
+
+console.log(\`\\nResults: \${pass} passed, \${fail} failed\`);
+process.exit(fail > 0 ? 1 : 0);
+`;
+}
+
+/** A source-text literal that is a valid value for a scaffolded field type. */
+function sampleLiteral(fieldType: string): string {
+  switch ((fieldType || "string").toLowerCase()) {
+    case "int": case "integer": return "1";
+    case "float": case "number": case "numeric": case "decimal": return "1.5";
+    case "bool": case "boolean": return "true";
+    case "datetime": return '"2020-01-01 00:00:00"';
+    case "blob": return '"x"';
+    default: return '"sample"';
+  }
+}
+
+/** model → real SQLite roundtrip (create / read back / missing → null). */
+function emitModelTest(model: string, table: string, fields: Array<[string, string]>): void {
+  const flds = fields.length > 0 ? fields : [["name", "string"] as [string, string]];
+  const payload = flds.map(([f, t]) => `${f}: ${sampleLiteral(t)}`).join(", ");
+  const stringField = flds.find(([, t]) => ["string", "str", "text"].includes((t || "string").toLowerCase()))?.[0];
+  const valueAssert = stringField
+    ? `\nassert("string field round-trips", fetched !== null && (fetched.toObject() as Record<string, unknown>).${stringField} === "sample");`
+    : "";
+  const doc = `/**
+ * Real ORM roundtrip for ${model} — no mocks, real SQLite.
+ *
+ * Generated with src/models/${model}.ts by \`tina4nodejs generate model
+ * ${model}\`. The model scaffold is working code, so this passes on generation:
+ * binds a real in-memory SQLite DB, creates the table, saves a row, reads it
+ * back. Run with: npx tsx tests/${table}_model.test.ts
+ */
+import ${model} from "../src/models/${model}.js";
+import { initDatabase } from "tina4-nodejs/orm";`;
+  const body = `await initDatabase({ url: "sqlite:///:memory:" });
+await ${model}.createTable();
+
+const row = new ${model}({ ${payload} });
+const saved = await row.save();
+assert("create() persists and returns the row", saved !== false && Boolean(row.toObject().id));
+
+const id = row.toObject().id;
+const fetched = await ${model}.selectOne("SELECT * FROM ${table} WHERE id = ?", [id]);
+assert("row reads back by id", fetched !== null);
+assert("read-back id matches", fetched !== null && (fetched.toObject() as Record<string, unknown>).id === id);${valueAssert}
+
+const missing = await ${model}.selectOne("SELECT * FROM ${table} WHERE id = ?", [999999]);
+assert("find missing returns null", missing === null);`;
+  writeTest(`${table}_model`, standaloneTest(doc, body));
+}
+
+/** route (no --model) → real Router registration + the list handler is a live
+ *  loud stub. (route --model reuses the secure-gate generateTest instead.) */
+function emitRouteStubTest(route: string): void {
+  const doc = `/**
+ * Routing test for ${route} — no mocks, real Router + route discovery.
+ *
+ * Generated with src/routes/api/${route}/ by \`tina4nodejs generate route
+ * ${route}\` (no --model). The handlers are AI-FILL stubs that throw until you
+ * implement them, so this tests what IS live on generation: all five routes
+ * register on the REAL Router, and the list handler fails loud until filled.
+ * Run with: npx tsx tests/${route}.test.ts
+ */
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Router, discoverRoutes } from "tina4-nodejs";
+import listHandler from "../src/routes/api/${route}/get.js";`;
+  const body = `const here = dirname(fileURLToPath(import.meta.url));
+const router = new Router();
+const defs = await discoverRoutes(resolve(here, "../src/routes"));
+for (const def of defs) router.addRoute(def);
+
+const sigs = defs.map((d) => \`\${d.method} \${d.pattern}\`);
+for (const sig of ["GET /api/${route}", "POST /api/${route}", "GET /api/${route}/{id}", "PUT /api/${route}/{id}", "DELETE /api/${route}/{id}"]) {
+  assert(\`route registered: \${sig}\`, sigs.includes(sig));
+}
+
+// The scaffolded list handler is a loud AI-FILL stub — it throws until filled.
+await assertThrows("list handler is a live stub (throws until filled)",
+  () => listHandler({} as never, {} as never));`;
+  writeTest(route, standaloneTest(doc, body));
+}
+
+/** middleware → the scaffolded before/after driven through the REAL
+ *  MiddlewareChain with a real Request/Response (no mock req/res). */
+function emitMiddlewareTest(name: string, snake: string): void {
+  const doc = `/**
+ * Real dispatch test for the ${name} middleware — no mocks.
+ *
+ * Generated with src/middleware/${snake}.ts by \`tina4nodejs generate middleware
+ * ${name}\`. Drives the scaffolded before/after functions through the REAL
+ * MiddlewareChain with a real Tina4Request/Response (built from real node http
+ * objects) — the same continuation dispatch the live server runs.
+ * Run with: npx tsx tests/${snake}.test.ts
+ */
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Socket } from "node:net";
+import { MiddlewareChain, createRequest, createResponse } from "tina4-nodejs";
+import type { Tina4Request, Tina4Response } from "tina4-nodejs";
+import { before${name}, after${name} } from "../src/middleware/${snake}.js";`;
+  const body = `function realPair(headers: Record<string, string>): { req: Tina4Request; res: Tina4Response; raw: ServerResponse } {
+  const socket = new Socket();
+  const rawReq = new IncomingMessage(socket);
+  rawReq.method = "GET";
+  rawReq.url = "/";
+  rawReq.headers = { ...headers, host: "localhost" };
+  rawReq.push(null);
+  const rawRes = new ServerResponse(rawReq);
+  rawRes.write = (() => true) as typeof rawRes.write;
+  rawRes.end = (function (this: ServerResponse) { return this; }) as typeof rawRes.end;
+  return { req: createRequest(rawReq), res: createResponse(rawRes), raw: rawRes };
+}
+
+// before(): blocks an unauthenticated request (401, does not call next()).
+{
+  const chain = new MiddlewareChain();
+  chain.use(before${name});
+  let reached = false;
+  chain.use(async (_r, _s, next) => { reached = true; next(); });
+  const { req, res, raw } = realPair({});
+  await chain.run(req, res);
+  assert("before blocks unauthenticated (401, chain short-circuits)", raw.statusCode === 401 && reached === false);
+}
+
+// before(): lets an authenticated request through to the next middleware.
+{
+  const chain = new MiddlewareChain();
+  chain.use(before${name});
+  let reached = false;
+  chain.use(async (_r, _s, next) => { reached = true; next(); });
+  const { req, res } = realPair({ authorization: "Bearer test" });
+  await chain.run(req, res);
+  assert("before passes an authenticated request through", reached === true);
+}
+
+// after(): always continues the chain.
+{
+  const chain = new MiddlewareChain();
+  chain.use(after${name});
+  let reached = false;
+  chain.use(async (_r, _s, next) => { reached = true; next(); });
+  const { req, res } = realPair({});
+  await chain.run(req, res);
+  assert("after runs and continues the chain", reached === true);
+}`;
+  writeTest(snake, standaloneTest(doc, body));
+}
+
+/** service → registrable on a REAL ServiceRunner + descriptor shape + loud stub. */
+function emitServiceTest(name: string, snake: string, camel: string): void {
+  const doc = `/**
+ * Real ServiceRunner test for the ${name} service — no mocks.
+ *
+ * Generated with src/services/${snake}.ts by \`tina4nodejs generate service
+ * ${name}\`. Registers the scaffold on a REAL ServiceRunner and confirms the
+ * descriptor; the task body is an AI-FILL stub that throws until filled.
+ * Run with: npx tsx tests/${snake}.test.ts
+ */
+import { ServiceRunner } from "tina4-nodejs";
+import service, { ${camel}Task } from "../src/services/${snake}.js";`;
+  const body = `assert("descriptor has a name + callable handler",
+  service.name === "${snake}" && typeof service.handler === "function");
+
+// Register on a REAL ServiceRunner and confirm it is listed.
+ServiceRunner.register(service.name, service.handler, { interval: (service as { interval?: number }).interval });
+assert("registers on a real ServiceRunner", ServiceRunner.list().some((s) => s.name === "${snake}"));
+ServiceRunner.remove("${snake}");
+
+// The scaffolded task body is an AI-FILL stub — it throws until filled.
+await assertThrows("task is a live stub (throws until filled)", () => ${camel}Task({} as never));`;
+  writeTest(snake, standaloneTest(doc, body));
+}
+
+/** queue → push a REAL job onto the real file-backed Queue + daemon wiring. */
+function emitQueueTest(topic: string, slug: string, pascal: string): void {
+  const doc = `/**
+ * Real file-backed Queue test for the ${topic} worker — no mocks.
+ *
+ * Generated with src/services/${slug}_consumer.ts by \`tina4nodejs generate
+ * queue ${topic}\`. Pushes a REAL job onto the real file-backed Queue and
+ * asserts it is enqueued, and that the consumer is wired as a daemon. The
+ * per-job handle is an AI-FILL stub that throws until filled.
+ * Run with: npx tsx tests/${slug}.test.ts
+ */
+import { Queue } from "tina4-nodejs";
+import worker, { publish${pascal}, handle${pascal} } from "../src/services/${slug}_consumer.js";`;
+  const body = `const jobId = publish${pascal}({ hello: "world" });
+assert("publish enqueues a real job (returns an id)", typeof jobId === "string" && jobId.length > 0);
+assert("the job is really on the queue", new Queue({ topic: "${topic}" }).size() >= 1);
+
+assert("consumer default export is a daemon", worker.daemon === true);
+assert("consumer handler is wired", typeof worker.handler === "function");
+
+// The per-job handler is an AI-FILL stub — it throws until filled.
+await assertThrows("handle is a live stub (throws until filled)", () => handle${pascal}({}));`;
+  writeTest(slug, standaloneTest(doc, body));
+}
+
+/** validator → run the scaffold against valid + invalid real input
+ *  (working-default: ships a starter required("name") rule). */
+function emitValidatorTest(name: string, snake: string, pascal: string): void {
+  const doc = `/**
+ * Real validation test for validate${pascal} — no mocks.
+ *
+ * Generated with src/validators/${snake}.ts by \`tina4nodejs generate validator
+ * ${name}\`. The scaffold ships a starter rule (required "name"), so this passes
+ * on generation — adjust the rules for your payload and update these cases.
+ * Run with: npx tsx tests/${snake}.test.ts
+ */
+import { validate${pascal} } from "../src/validators/${snake}.js";`;
+  const body = `assert("valid input passes", validate${pascal}({ name: "Ada" }).isValid());
+
+const bad = validate${pascal}({});
+assert("invalid input fails", bad.isValid() === false);
+assert("invalid input reports errors", bad.errors().length > 0);`;
+  writeTest(snake, standaloneTest(doc, body));
+}
+
+/** seeder → run the scaffolded seeder against real SQLite, assert rows created
+ *  (working-default: fieldOverrides returns {}, seedOrm auto-fills). */
+function emitSeederTest(model: string, table: string): void {
+  const doc = `/**
+ * Real seeding test for the ${model} seeder — no mocks, real SQLite.
+ *
+ * Generated with src/seeds/${table}_seeder.ts by \`tina4nodejs generate seeder
+ * ${model}\`. Binds a real SQLite DB, creates the table, runs the scaffolded
+ * seeder (auto-fills every field via FakeData) and asserts rows were created.
+ * Run with: npx tsx tests/${table}_seeder.test.ts
+ */
+import { initDatabase, FakeData } from "tina4-nodejs/orm";
+import ${model} from "../src/models/${model}.js";
+import { fieldOverrides, run } from "../src/seeds/${table}_seeder.js";`;
+  const body = `process.env.TINA4_DATABASE_URL = "sqlite:///test_${table}_seeder.db";
+await initDatabase({ url: process.env.TINA4_DATABASE_URL });
+await ${model}.createTable();
+
+assert("fieldOverrides returns an object", typeof fieldOverrides(new FakeData()) === "object");
+
+await run();   // run() re-binds the same DB URL and seeds via seedOrm
+const rows = await ${model}.all();
+assert("run() seeds real rows", rows.length >= 1);`;
+  writeTest(`${table}_seeder`, standaloneTest(doc, body));
+}
+
+/** websocket → real Router registration + drive the real handler (socket-free
+ *  "close" event) directly; the "message" branch is a loud stub. */
+function emitWebsocketTest(wsPath: string, base: string, handler: string): void {
+  const doc = `/**
+ * Real handler test for the ${wsPath} WebSocket route — no mocks.
+ *
+ * Generated with src/routes/ws_${base}.ts by \`tina4nodejs generate websocket
+ * ...\`. Confirms the handler registers on the REAL Router (importing runs the
+ * module-level websocket() call) and drives the real handler for the "close"
+ * event (no socket needed). The "message" branch is an AI-FILL stub that throws
+ * until filled. Run with: npx tsx tests/ws_${base}.test.ts
+ */
+import { Router } from "tina4-nodejs";
+import { ${handler} } from "../src/routes/ws_${base}.js";  // importing registers via websocket()`;
+  const body = `assert("handler registered on the real router",
+  Router.getWebSocketRoutes().some((r) => r.pattern === "${wsPath}"));
+
+// The "close" branch returns cleanly without a live connection.
+const closed = await ${handler}(null as never, "close", "");
+assert("close event handled cleanly", closed === undefined);
+
+// The "message" branch is an AI-FILL stub — it throws until filled.
+await assertThrows("message branch is a live stub (throws until filled)",
+  () => ${handler}(null as never, "message", "hi"));`;
+  writeTest(`ws_${base}`, standaloneTest(doc, body));
+}
+
+/** listener → emit the REAL event on the real bus, assert the listener ran. */
+function emitListenerTest(event: string, slug: string): void {
+  const doc = `/**
+ * Real event-bus test for the '${event}' listener — no mocks.
+ *
+ * Generated with src/listeners/${slug}.ts by \`tina4nodejs generate listener
+ * ${event}\`. Confirms the listener binds on the REAL event bus (importing runs
+ * the module-level Events.on) and that emitting the event reaches it. The
+ * reaction body is an AI-FILL stub, so a strict emit re-raises here (proving it
+ * ran). Run with: npx tsx tests/${slug}.test.ts
+ */
+import { Events } from "tina4-nodejs";
+import "../src/listeners/${slug}.js";  // importing registers the listener via Events.on()`;
+  const body = `assert("listener registered on the real event bus", Events.listeners("${event}").length >= 1);
+
+// strict emit re-raises the stub error, proving the listener actually ran.
+await assertThrows("emitting the event reaches the (stub) listener",
+  () => Events.emit("${event}", { strict: true }, { id: 1 }));`;
+  writeTest(slug, standaloneTest(doc, body));
+}
+
+/** auth → real register / login / me end-to-end via the real TestClient. This
+ *  proves the token→200 path on /api/auth/me (the scaffold passes headers to
+ *  authenticateRequest, not the request — no always-401 bug). */
+function emitAuthTest(): void {
+  const doc = `/**
+ * Real auth test — register / login / me via the real TestClient.
+ *
+ * Generated with the auth scaffold by \`tina4nodejs generate auth\`. No mocks:
+ * real Router + route discovery, real Auth (PBKDF2 + JWT), real SQLite. register
+ * + login are public; the token from login authenticates GET /api/auth/me.
+ * Run with: npx tsx tests/auth.test.ts
+ */
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Router, TestClient, discoverRoutes } from "tina4-nodejs";
+import { initDatabase } from "tina4-nodejs/orm";
+import User from "../src/models/User.js";
+
+process.env.TINA4_SECRET = process.env.TINA4_SECRET ?? "test-secret";
+delete process.env.TINA4_API_KEY;
+const here = dirname(fileURLToPath(import.meta.url));`;
+  const body = `await initDatabase({ url: "sqlite:///test_auth.db" });
+await User.createTable();
+for (const existing of await User.all()) await existing.delete();   // start from an empty table
+
+const router = new Router();
+for (const def of await discoverRoutes(resolve(here, "../src/routes"))) router.addRoute(def);
+const client = new TestClient(router);
+
+const registered = await client.post("/api/auth/register", { json: { email: "a@b.c", password: "secret12" } });
+assert("register a new user -> 201", registered.status === 201);
+
+const duplicate = await client.post("/api/auth/register", { json: { email: "a@b.c", password: "secret12" } });
+assert("duplicate register -> 409", duplicate.status === 409);
+
+const login = await client.post("/api/auth/login", { json: { email: "a@b.c", password: "secret12" } });
+assert("login -> 200", login.status === 200);
+const token = (login.json() as { token?: string }).token;
+assert("login returns a token", typeof token === "string" && token.length > 0);
+
+const me = await client.get("/api/auth/me", { headers: { authorization: \`Bearer \${token}\` } });
+assert("authenticated GET /api/auth/me -> 200 (token accepted)", me.status === 200);
+assert("me returns the authenticated user's email",
+  ((me.json() as { user?: { email?: string } }).user?.email) === "a@b.c");
+
+const anon = await client.get("/api/auth/me");
+assert("anonymous GET /api/auth/me -> 401", anon.status === 401);
+
+const bad = await client.post("/api/auth/login", { json: { email: "a@b.c", password: "WRONG" } });
+assert("wrong password -> 401", bad.status === 401);`;
+  writeTest("auth", standaloneTest(doc, body));
+}
+
+/** migration (create_*) → apply UP then DOWN against real SQLite, assert the
+ *  table appears then disappears. Only for CREATE migrations. */
+function emitMigrationTest(migrationName: string, table: string): void {
+  const doc = `/**
+ * Real migration test for ${migrationName} — no mocks, real SQLite.
+ *
+ * Generated with the migration by \`tina4nodejs generate migration
+ * ${migrationName}\`. Applies the generated UP SQL against a fresh real
+ * in-memory SQLite database and asserts the table exists, then applies the DOWN
+ * SQL and asserts it is gone — the raw SQL the migration runner executes.
+ * Run with: npx tsx tests/${table}_migration.test.ts
+ */
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readdirSync, readFileSync } from "node:fs";
+import { SQLiteAdapter } from "tina4-nodejs/orm";`;
+  const body = `const here = dirname(fileURLToPath(import.meta.url));
+const migrationsDir = resolve(here, "../migrations");
+
+const upFile = readdirSync(migrationsDir).find((f) => f.endsWith("_${migrationName}.sql") && !f.endsWith(".down.sql"));
+assert("generated UP migration file exists", Boolean(upFile));
+const downFile = upFile!.replace(/\\.sql$/, ".down.sql");
+
+function statements(sql: string): string[] {
+  const noComments = sql.split("\\n").filter((l) => !l.trim().startsWith("--")).join("\\n");
+  return noComments.split(";").map((s) => s.trim()).filter(Boolean);
+}
+
+const upText = readFileSync(join(migrationsDir, upFile!), "utf-8");
+const upSql = upText.split("-- UP")[1].split("-- DOWN")[0];
+const downSql = readFileSync(join(migrationsDir, downFile), "utf-8");
+
+const db = new SQLiteAdapter(":memory:");
+for (const stmt of statements(upSql)) db.execute(stmt);
+assert("UP creates the ${table} table", db.tableExists("${table}"));
+
+for (const stmt of statements(downSql)) db.execute(stmt);
+assert("DOWN drops the ${table} table", db.tableExists("${table}") === false);`;
+  writeTest(`${table}_migration`, standaloneTest(doc, body));
 }