@deterministic-code/datasources-cli 0.0.0-stage → 0.1.3

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/package.json.tmpl

@@ -0,0 +1,32 @@
+{
+  "name": "{{application_name}}",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@tanstack/react-query": "^5.64.2",
+    "axios": "^1.7.9",
+    "zod": "^3.23.8"
+  },
+  "allowScripts": {
+    "esbuild": true
+  },
+  "overrides": {
+    "glob": "^13.0.6"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^9.9.0",
+    "@sveltejs/vite-plugin-svelte": "^4.0.4",
+    "@tsconfig/svelte": "^5.0.4",
+    "svelte": "^5.16.0",
+    "typescript": "^5.7.0",
+    "vite": "^5.0.8",
+    "vitest": "^2.1.8"
+  }
+}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/src/App.svelte.tmpl

@@ -0,0 +1 @@
+<h1>{{application_name}}</h1>

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/src/main.ts.tmpl

@@ -0,0 +1,4 @@
+import { mount } from "svelte";
+import {{appComponentName}} from "./{{appFileBase}}.svelte";
+
+mount({{appComponentName}}, { target: document.getElementById("app")! });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/src/vite-env.d.ts.tmpl

@@ -0,0 +1,2 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/svelte.config.js.tmpl

@@ -0,0 +1,5 @@
+import { vitePreprocess } from "@sveltejs/vite-plugin-svelte";
+
+export default {
+  preprocess: vitePreprocess(),
+};

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/tsconfig.json.tmpl

@@ -0,0 +1,15 @@
+{
+  "extends": "@tsconfig/svelte/tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/svelte/vite.config.ts.tmpl

@@ -0,0 +1,10 @@
+import { defineConfig } from "vite";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+
+export default defineConfig({
+  plugins: [svelte()],
+  test: {
+    environment: "node",
+    include: ["src/**/*.test.ts"],
+  },
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/tsconfig.json.tmpl

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-app/vite.config.ts.tmpl

@@ -0,0 +1,10 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: "node",
+    include: ["src/**/*.test.ts"],
+  },
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-validators/index.ts.tmpl

@@ -0,0 +1,5 @@
+{{#types}}export { {{exports}} } from "./{{fileBase}}";
+{{#withTypeAnnotation}}
+export type { {{validatedTypeName}} } from "./{{fileBase}}";
+{{/withTypeAnnotation}}
+{{/types}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-validators/schema-inherit.ts.tmpl

@@ -0,0 +1,5 @@
+export const {{schemaName}} = {{dsAlias}}{{#hasOmits}}.omit({ {{&omitObj}} }){{/hasOmits}}{{#partialId}}.partial({ id: true }){{/partialId}}{{#hasFields}}.extend({
+{{#fields}}
+  {{ident}}: {{&zodExpr}},
+{{/fields}}
+}){{/hasFields}};

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-validators/schema-standalone.ts.tmpl

@@ -0,0 +1,10 @@
+export const {{schemaName}} = {{#emptyObject}}z.object({}){{/emptyObject}}{{^emptyObject}}z.object({
+{{#fields}}
+  {{ident}}: {{&zodExpr}},
+{{/fields}}
+}){{/emptyObject}};
+{{#hasTrio}}
+export const {{createName}} = {{schemaName}};
+export const {{updateName}} = {{schemaName}};
+export const {{patchName}} = {{schemaName}}.partial();
+{{/hasTrio}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-validators/schema-union.ts.tmpl

@@ -0,0 +1,4 @@
+export const {{schemaName}} = z.union([
+{{#members}}  z.lazy(() => {{ident}}),
+{{/members}}
+]);

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-frontend-validators/type.ts.tmpl

@@ -0,0 +1,11 @@
+// schema-version: {{schemaVersion}}
+import { z } from "zod";
+{{#imports}}
+import { {{names}} } from "{{fromPath}}";
+{{/imports}}
+
+{{&schemaBody}}
+{{#withTypeAnnotation}}
+
+export type {{validatedTypeName}} = z.infer<typeof {{schemaName}}>;
+{{/withTypeAnnotation}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-migrate-scripts/setup-typescript.mjs.tmpl

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import Database from "better-sqlite3";
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(here, "..");
+const dbPath = process.env.DB_PATH ?? process.env.SQLITE_PATH ?? "./dev.sqlite";
+const migrateDir = join(projectRoot, "sql", "sqlite", "migrations");
+
+const SETUP_DDL = [
+  `CREATE TABLE IF NOT EXISTS "migrates" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "name" VARCHAR(255) NOT NULL UNIQUE,
+  "checksum" VARCHAR(64),
+  "created" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updated" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);`,
+  `CREATE TABLE IF NOT EXISTS "migrate_logs" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "migrate_name" VARCHAR(255) NOT NULL,
+  "direction" VARCHAR(8) NOT NULL,
+  "status" VARCHAR(16) NOT NULL,
+  "finished_at" DATETIME,
+  "duration_ms" INTEGER,
+  "error_message" TEXT,
+  "created" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updated" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);`,
+];
+
+async function main() {
+  const db = new Database(dbPath);
+  try {
+    for (const ddl of SETUP_DDL) db.exec(ddl);
+
+    const appliedRows = db.prepare("SELECT name FROM migrates").all();
+    const applied = new Set(appliedRows.map((r) => r.name));
+
+    let files;
+    try {
+      files = (await readdir(migrateDir))
+        .filter((f) => f.endsWith("_up.sql"))
+        .sort();
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        console.log("setup: no migrations dir found, schema_migrations only.");
+        return;
+      }
+      throw err;
+    }
+
+    let pending = 0;
+    for (const name of files) {
+      if (applied.has(name)) continue;
+      pending++;
+      const sql = await readFile(join(migrateDir, name), "utf8");
+      const start = Date.now();
+      try {
+        const apply = db.transaction(() => {
+          db.exec(sql);
+          db.prepare("INSERT INTO migrates (name) VALUES (?)").run(name);
+        });
+        apply();
+        const ms = Date.now() - start;
+        db.prepare(
+          "INSERT INTO migrate_logs (migrate_name, direction, status, finished_at, duration_ms) VALUES (?, 'up', 'success', CURRENT_TIMESTAMP, ?)",
+        ).run(name, ms);
+        console.log(`  applied ${name} (${ms}ms)`);
+      } catch (err) {
+        const ms = Date.now() - start;
+        db.prepare(
+          "INSERT INTO migrate_logs (migrate_name, direction, status, finished_at, duration_ms, error_message) VALUES (?, 'up', 'error', CURRENT_TIMESTAMP, ?, ?)",
+        ).run(name, ms, String(err?.message ?? err));
+        throw err;
+      }
+    }
+    if (pending === 0) console.log("setup: no pending migrations.");
+    else console.log(`setup: applied ${pending} migration(s).`);
+  } finally {
+    db.close();
+  }
+}
+
+main().catch((err) => {
+  console.error("setup failed:", err?.stack ?? err);
+  process.exit(1);
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-perf-e2e/app.perf.client.test.ts.tmpl

@@ -0,0 +1,257 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { readFile, access } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
+
+const ITERATIONS = Number(process.env.PERF_ITERATIONS ?? "100");
+const WARMUP = Number(process.env.PERF_WARMUP_ITERATIONS ?? "0");
+const BASE_URL = process.env.PERF_BASE_URL ?? "http://127.0.0.1:3000";
+const DIALECT = process.env.PERF_DIALECT ?? process.env.DATABASE_BACKEND ?? "sqlite";
+const LANGUAGE = process.env.PERF_LANGUAGE ?? "typescript";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function findDeterministicDir(): Promise<string> {
+  let cur = __dirname;
+  for (let i = 0; i < 6; i++) {
+    const candidate = resolve(cur, "deterministic", "performance-plan.yaml");
+    if (await access(candidate).then(() => true, () => false)) return resolve(cur, "deterministic");
+    cur = resolve(cur, "..");
+  }
+  return resolve(__dirname, "..", "deterministic");
+}
+
+interface PerfStep {
+  id: string;
+  phase: "lookup" | "iter" | "iter_teardown";
+  op: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: string;
+  body?: Record<string, unknown>;
+  if_match?: string;
+  capture?: Record<string, string>;
+}
+interface PerfPlan {
+  project_name?: string;
+  steps: PerfStep[];
+}
+
+async function loadYaml<T>(p: string): Promise<T> {
+  return yaml.load(await readFile(p, "utf8")) as T;
+}
+
+function randSuffix(): string {
+  return \`\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2, 8)}\`;
+}
+
+interface RunCtx {
+  ids: Record<string, Array<number | string>>;
+  lookups: Record<string, { ids: Array<number | string>; first_id: number | string | null; first_name: number | string | null }>;
+  i: number;
+}
+
+function resolveTemplate(value: unknown, ctx: RunCtx): unknown {
+  if (typeof value !== "string") return value;
+  const isPureSubstitution = /^\\\$\\{[^}]+\\}$/.test(value);
+  const replaced = value.replace(/\\\$\\{([^}]+)\\}/g, (_m, expr) => {
+    const trimmed = expr.trim();
+    if (trimmed === "randSuffix()") return randSuffix();
+    if (trimmed === "i") return String(ctx.i);
+    const idsMatch = trimmed.match(/^ids\\.([a-z_][a-z0-9_]*)\\[i\\]$/i);
+    if (idsMatch) {
+      const pool = ctx.ids[idsMatch[1]];
+      if (!pool || pool[ctx.i] === undefined) throw new Error(\`unresolved \${trimmed} (pool length=\${pool?.length ?? 0}, i=\${ctx.i})\`);
+      return String(pool[ctx.i]);
+    }
+    const lookupFirst = trimmed.match(/^lookups\\.([a-z_][a-z0-9_]*)\\.first_id$/i);
+    if (lookupFirst) {
+      const lk = ctx.lookups[lookupFirst[1]];
+      if (!lk || lk.first_id === null) throw new Error(\`unresolved \${trimmed}\`);
+      return String(lk.first_id);
+    }
+    const lookupFirstName = trimmed.match(/^lookups\\.([a-z_][a-z0-9_]*)\\.first_name$/i);
+    if (lookupFirstName) {
+      const lk = ctx.lookups[lookupFirstName[1]];
+      if (!lk || lk.first_name === null) throw new Error(\`unresolved \${trimmed}\`);
+      return String(lk.first_name);
+    }
+    const lookupIdxMatch = trimmed.match(/^lookups\\.([a-z_][a-z0-9_]*)\\.ids\\[(\\d+)\\]$/i);
+    if (lookupIdxMatch) {
+      const lk = ctx.lookups[lookupIdxMatch[1]];
+      const idx = Number(lookupIdxMatch[2]);
+      if (!lk || lk.ids[idx] === undefined) throw new Error(\`unresolved \${trimmed}\`);
+      return String(lk.ids[idx]);
+    }
+    throw new Error(\`unrecognized template expression \${trimmed}\`);
+  });
+  if (isPureSubstitution && /^-?\\d+$/.test(replaced)) return Number(replaced);
+  return replaced;
+}
+
+function resolveTemplateDeep(value: unknown, ctx: RunCtx): unknown {
+  if (Array.isArray(value)) return value.map((v) => resolveTemplateDeep(v, ctx));
+  if (value !== null && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = resolveTemplateDeep(v, ctx);
+    }
+    return out;
+  }
+  return resolveTemplate(value, ctx);
+}
+
+function resolveBody(body: Record<string, unknown> | undefined, ctx: RunCtx): Record<string, unknown> | undefined {
+  if (!body) return undefined;
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(body)) out[k] = resolveTemplateDeep(v, ctx);
+  return out;
+}
+
+function extractByJsonPath(body: unknown, path: string): unknown {
+  const itemsFirst = path.match(/^\\\$\\.items\\[0\\]\\.([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (itemsFirst) {
+    const col = itemsFirst[1];
+    const items = (body as { items?: Array<Record<string, unknown>> })?.items;
+    return Array.isArray(items) && items[0] ? items[0][col] ?? null : null;
+  }
+  const itemsAll = path.match(/^\\\$\\.items\\[\\*\\]\\.([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (itemsAll) {
+    const col = itemsAll[1];
+    const items = (body as { items?: Array<Record<string, unknown>> })?.items;
+    return Array.isArray(items) ? items.map((it) => it[col] ?? null) : [];
+  }
+  const scalar = path.match(/^\\\$\\.([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (scalar) {
+    const col = scalar[1];
+    const direct = (body as Record<string, unknown>)?.[col];
+    if (direct !== undefined) return direct;
+    const item = (body as { item?: Record<string, unknown> })?.item;
+    if (item && item[col] !== undefined) return item[col];
+    return null;
+  }
+  throw new Error(\`unsupported JSONPath \${path}\`);
+}
+
+function applyCapture(captureSpec: Record<string, string> | undefined, body: unknown, ctx: RunCtx): void {
+  if (!captureSpec) return;
+  for (const [target, jsonPath] of Object.entries(captureSpec)) {
+    const value = extractByJsonPath(body, jsonPath);
+    if (target.startsWith("ids.")) {
+      const m = target.match(/^ids\\.([a-z_][a-z0-9_]*)\\[i\\]$/i);
+      if (!m) throw new Error(\`unsupported capture target \${target}\`);
+      const entity = m[1];
+      if (!ctx.ids[entity]) ctx.ids[entity] = [];
+      ctx.ids[entity][ctx.i] = value as number | string;
+    } else if (target.startsWith("lookups.")) {
+      const m = target.match(/^lookups\\.([a-z_][a-z0-9_]*)\\.(ids|first_id|first_name)$/);
+      if (!m) throw new Error(\`unsupported capture target \${target}\`);
+      const entity = m[1];
+      if (!ctx.lookups[entity]) ctx.lookups[entity] = { ids: [], first_id: null, first_name: null };
+      if (m[2] === "ids") ctx.lookups[entity].ids = Array.isArray(value) ? (value as Array<number | string>) : [];
+      else if (m[2] === "first_id") ctx.lookups[entity].first_id = (value as number | string) ?? null;
+      else ctx.lookups[entity].first_name = (value as number | string) ?? null;
+    }
+  }
+}
+
+function expectedStatusFor(op: PerfStep["op"]): number[] {
+  switch (op) {
+    case "POST": return [201];
+    case "GET":
+    case "PUT":
+    case "PATCH": return [200];
+    case "DELETE": return [200, 204];
+  }
+}
+
+async function executeStep(step: PerfStep, ctx: RunCtx, timings: Record<string, number[]>, record: boolean = true): Promise<void> {
+  const path = resolveTemplate(step.path, ctx) as string;
+  const body = resolveBody(step.body, ctx);
+  const url = BASE_URL + path;
+  const headers: Record<string, string> = {};
+  if (body) headers["Content-Type"] = "application/json";
+  if (step.if_match) {
+    const token = String(resolveTemplate(step.if_match, ctx));
+    if (token === "" || token === "null") {
+      throw new Error(\`step \${step.id}: If-Match \${step.if_match} resolved to '\${token}' — the captured updated token is missing (empty version pool)\`);
+    }
+    headers["If-Match"] = token;
+  }
+  const init: RequestInit = {
+    method: step.op,
+    headers: Object.keys(headers).length > 0 ? headers : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  };
+  const t0 = performance.now();
+  const res = await fetch(url, init);
+  const elapsed = performance.now() - t0;
+  if (record) {
+    if (!timings[step.id]) timings[step.id] = [];
+    timings[step.id].push(elapsed);
+  }
+  const expected = expectedStatusFor(step.op);
+  if (!expected.includes(res.status)) {
+    const bodyText = await res.text().catch((err: unknown) => { console.warn("perf e2e: response body read failed; continuing with empty body", err); return ""; });
+    const sentJson = body === undefined ? "<none>" : JSON.stringify(body);
+    throw new Error(\`step \${step.id} \${step.op} \${url} expected \${expected.join("|")} got \${res.status} body=\${bodyText.slice(0, 500)} sent=\${sentJson.slice(0, 500)}\`);
+  }
+  if (step.capture) {
+    const json = await res.json().catch(() => null);
+    applyCapture(step.capture, json, ctx);
+  }
+}
+
+let plan: PerfPlan;
+const ctx: RunCtx = { ids: {}, lookups: {}, i: 0 };
+const timings: Record<string, number[]> = {};
+const stepOpById = new Map<string, PerfStep["op"]>();
+const stepPathById = new Map<string, string>();
+
+beforeAll(async () => {
+  const deterministicDir = process.env.PERF_DETERMINISTIC_DIR ?? (await findDeterministicDir());
+  const planPath = process.env.PERF_PLAN_PATH ?? resolve(deterministicDir, "performance-plan.yaml");
+  plan = await loadYaml<PerfPlan>(planPath);
+  for (const s of plan.steps) {
+    stepOpById.set(s.id, s.op);
+    stepPathById.set(s.id, s.path);
+  }
+  const lookupSteps = plan.steps.filter((s) => s.phase === "lookup");
+  const iterSteps = plan.steps.filter((s) => s.phase === "iter");
+  const teardownSteps = plan.steps.filter((s) => s.phase === "iter_teardown");
+  if (WARMUP > 0) {
+    for (const step of lookupSteps) await executeStep(step, ctx, timings, false);
+    for (let w = 0; w < WARMUP; w++) {
+      const warmupCtx: RunCtx = { ids: {}, lookups: ctx.lookups, i: w };
+      for (const step of iterSteps) await executeStep(step, warmupCtx, timings, false);
+      for (const step of teardownSteps) await executeStep(step, warmupCtx, timings, false);
+    }
+  }
+  for (const step of lookupSteps) await executeStep(step, ctx, timings, true);
+});
+
+afterAll(async () => {
+  for (const [id, samples] of Object.entries(timings)) {
+    if (samples.length === 0) continue;
+    const sorted = [...samples].sort((a, b) => a - b);
+    const p50 = sorted[Math.floor(0.50 * sorted.length)];
+    const p95 = sorted[Math.min(sorted.length - 1, Math.floor(0.95 * sorted.length))];
+    const max = Math.max(...samples);
+    const op = stepOpById.get(id) ?? "?";
+    const path = stepPathById.get(id) ?? "?";
+    const iso = new Date().toISOString();
+    console.log(\`[\${iso}]-[perf-e2e][Finish]-[\${op} \${path}] step_id=\${id} language=\${LANGUAGE} dialect=\${DIALECT} iterations=\${samples.length} p50=\${Math.round(p50 * 1000) / 1000}ms p95=\${Math.round(p95 * 1000) / 1000}ms max=\${Math.round(max * 1000) / 1000}ms\`);
+  }
+});
+
+describe(\`perf-e2e — execute performance-plan.yaml × \${ITERATIONS} against \${BASE_URL}\`, () => {
+  for (let iter = 0; iter < Number(process.env.PERF_ITERATIONS ?? "100"); iter++) {
+    it(\`iteration \${iter}\`, async () => {
+      ctx.i = iter;
+      for (const step of plan.steps.filter((s) => s.phase === "iter")) {
+        await executeStep(step, ctx, timings);
+      }
+      for (const step of plan.steps.filter((s) => s.phase === "iter_teardown")) {
+        await executeStep(step, ctx, timings);
+      }
+    });
+  }
+  it("metrics generated", () => { expect(true).toBe(true); });
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-perf-server/perf-server.ts.tmpl

@@ -0,0 +1,19 @@
+import { once } from "node:events";
+import { createServer } from "node:http";
+import { {{appFnName}} } from "./{{appFileBase}}.js";
+
+const port = Number(process.env.PORT ?? 4000);
+
+const app = await {{appFnName}}();
+const server = createServer(app);
+server.listen(port);
+await once(server, "listening");
+
+const shutdown = async () => {
+  server.close();
+  await once(server, "close");
+  process.exit(0);
+};
+
+process.on("SIGTERM", () => void shutdown());
+process.on("SIGINT", () => void shutdown());

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/by-field-delete-list.ts.tmpl

@@ -0,0 +1,13 @@
+  router.delete("/{{byField}}/:{{byField}}", async (req, res, next) => {
+    try {
+      const value = req.params.{{byField}} ?? "";
+      const count = await service.deleteBy([{ name: "{{byField}}", value }]);
+      if (count === 0) {
+        sendError(res, 404, "NOT_FOUND", `{{entity}} with {{byField}} '${value}' not found`);
+        return;
+      }
+      sendItem(res, { count });
+    } catch (err) {
+      next(err);
+    }
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/by-field-delete-unique.ts.tmpl

@@ -0,0 +1,17 @@
+  router.delete("/{{byField}}/:{{byField}}", async (req, res, next) => {
+    try {
+      const value = req.params.{{byField}} ?? "";
+      const count = await service.deleteBy([{ name: "{{byField}}", value }]);
+      if (count === 0) {
+        sendError(res, 404, "NOT_FOUND", `{{entity}} with {{byField}} '${value}' not found`);
+        return;
+      }
+      if (count > 1) {
+        sendError(res, 409, "CONFLICT", `Multiple {{entity}} rows matched {{byField}}='${value}'`);
+        return;
+      }
+      sendItem(res, { success: true });
+    } catch (err) {
+      next(err);
+    }
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/by-field-get-list.ts.tmpl

@@ -0,0 +1,9 @@
+  router.get("/{{byField}}/:{{byField}}", async (req, res, next) => {
+    try {
+      const value = req.params.{{byField}} ?? "";
+      const rows = await service.findBy([{ name: "{{byField}}", value }]);
+      sendItems(res, rows as unknown[]);
+    } catch (err) {
+      next(err);
+    }
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/by-field-get-unique.ts.tmpl

@@ -0,0 +1,17 @@
+  router.get("/{{byField}}/:{{byField}}", async (req, res, next) => {
+    try {
+      const value = req.params.{{byField}} ?? "";
+      const rows = await service.findBy([{ name: "{{byField}}", value }]);
+      if (rows.length === 0) {
+        sendError(res, 404, "NOT_FOUND", `{{entity}} with {{byField}} '${value}' not found`);
+        return;
+      }
+      if (rows.length > 1) {
+        sendError(res, 409, "CONFLICT", `Multiple {{entity}} rows matched {{byField}}='${value}'`);
+        return;
+      }
+      sendItem(res, rows[0] as unknown as Record<string, unknown>);
+    } catch (err) {
+      next(err);
+    }
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/by-field-put-list.ts.tmpl

@@ -0,0 +1,14 @@
+  router.put("/{{byField}}/:{{byField}}", async (req, res, next) => {
+    try {
+      const value = req.params.{{byField}} ?? "";
+      const parsed = updateSchema.parse(req.body);
+      const count = await service.updateBy(
+        [{ name: "{{byField}}", value }],
+        parsed as Record<string, unknown>,
+      );
+      sendItem(res, { count });
+    } catch (err) {
+      if (handleZodError(err, res)) return;
+      next(err);
+    }
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/by-field-put-unique.ts.tmpl

@@ -0,0 +1,23 @@
+  router.put("/{{byField}}/:{{byField}}", async (req, res, next) => {
+    try {
+      const value = req.params.{{byField}} ?? "";
+      const parsed = updateSchema.parse(req.body);
+      const count = await service.updateBy(
+        [{ name: "{{byField}}", value }],
+        parsed as Record<string, unknown>,
+      );
+      if (count === 0) {
+        sendError(res, 404, "NOT_FOUND", `{{entity}} with {{byField}} '${value}' not found`);
+        return;
+      }
+      if (count > 1) {
+        sendError(res, 409, "CONFLICT", `Multiple {{entity}} rows matched {{byField}}='${value}'`);
+        return;
+      }
+      const rows = await service.findBy([{ name: "{{byField}}", value }]);
+      sendItem(res, (rows[0] ?? null) as unknown as Record<string, unknown>);
+    } catch (err) {
+      if (handleZodError(err, res)) return;
+      next(err);
+    }
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/crud.ts.tmpl

@@ -0,0 +1,6 @@
+{{#simpleDoc}}/** Route {{fnName}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Route {{fnName}}.
+ * Datasource type: {{datasourceType}}.
+ */
+{{/descriptionDoc}}export function {{fnName}}() {}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/custom-stub.ts.tmpl

@@ -0,0 +1,13 @@
+{{#simpleDoc}}/** Route {{interfaceName}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Route {{interfaceName}}.
+ * Datasource type: standard.
+ */
+{{/descriptionDoc}}export interface {{interfaceName}} {}
+
+{{#simpleDoc}}/** Route {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Route {{className}}.
+ * Datasource type: standard.
+ */
+{{/descriptionDoc}}export class {{className}} implements {{interfaceName}} {}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/index.ts.tmpl

@@ -0,0 +1,4 @@
+{{#routers}}export { {{fnName}} } from "./{{fileBase}}";
+{{/routers}}{{#types}}export { {{className}} } from "./{{fileBase}}";
+export type { {{interfaceName}} } from "./{{fileBase}}";
+{{/types}}