postgresdk 0.1.1-alpha.0

package/dist/src/emit-include-loader.js

@@ -0,0 +1,299 @@
+/**
+ * Emit a generic include loader that:
+ * - Walks the include spec
+ * - Loads children in batches per edge kind
+ * - Stitches onto parent rows (mutates copies)
+ */
+export function emitIncludeLoader(graph, model, maxDepth) {
+    // Precompute helpful maps for FK discovery
+    const fkIndex = {};
+    for (const t of Object.values(model.tables)) {
+        fkIndex[t.name] = t.fks.map((f) => ({ from: f.from, toTable: f.toTable, to: f.to }));
+    }
+    return `/* Generated. Do not edit. */
+import { RELATION_GRAPH } from "./include-builder";
+
+// Minimal types to keep the file self-contained
+type Graph = typeof RELATION_GRAPH;
+type TableName = keyof Graph;
+type IncludeSpec = any;
+
+// Debug helpers (enabled with SDK_DEBUG=1)
+const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
+const log = {
+  debug: (...args: any[]) => { if (DEBUG) console.debug("[sdk:include]", ...args); },
+  warn:  (...args: any[]) => console.warn("[sdk:include]", ...args),
+  error: (...args: any[]) => console.error("[sdk:include]", ...args),
+};
+
+// Helpers for PK/FK discovery from model (inlined)
+const FK_INDEX = ${JSON.stringify(fkIndex, null, 2)} as const;
+const PKS = ${JSON.stringify(Object.fromEntries(Object.values(model.tables).map((t) => [t.name, t.pk])), null, 2)} as const;
+
+// Build WHERE predicate for OR-of-AND on composite values
+function buildOrAndPredicate(cols: string[], count: number, startIndex: number) {
+  // Generates: (c1=$i AND c2=$i+1) OR (c1=$j AND c2=$j+1) ...
+  const groups: string[] = [];
+  let idx = startIndex;
+  for (let k = 0; k < count; k++) {
+    const parts = cols.map((c, j) => \`"\${c}" = $\${idx + j}\`);
+    groups.push('(' + parts.join(' AND ') + ')');
+    idx += cols.length;
+  }
+  return groups.join(' OR ');
+}
+
+// Extract distinct tuples from rows
+function distinctTuples(rows: any[], cols: string[]): any[] {
+  const s = new Set<string>();
+  const res: any[] = [];
+  for (const r of rows) {
+    const tup = cols.map(c => r[c]);
+    const key = JSON.stringify(tup);
+    if (!s.has(key)) {
+      s.add(key);
+      res.push(tup);
+    }
+  }
+  return res;
+}
+
+// Index rows by tuple key
+function indexByTuple(rows: any[], cols: string[]) {
+  const map = new Map<string, any>();
+  for (const r of rows) {
+    const key = JSON.stringify(cols.map(c => r[c]));
+    map.set(key, r);
+  }
+  return map;
+}
+
+// Group rows by tuple key (1:N)
+function groupByTuple(rows: any[], cols: string[]) {
+  const map = new Map<string, any[]>();
+  for (const r of rows) {
+    const key = JSON.stringify(cols.map(c => r[c]));
+    const arr = map.get(key) ?? [];
+    arr.push(r);
+    map.set(key, arr);
+  }
+  return map;
+}
+
+// Public entry
+export async function loadIncludes(
+  root: TableName,
+  parents: any[],
+  spec: IncludeSpec | undefined,
+  pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> },
+  maxDepth: number = ${maxDepth}
+) {
+  try {
+    if (!spec || !parents.length) return parents;
+    log.debug("loadIncludes root/spec/rows", root, Object.keys(spec ?? {}).length, parents.length);
+
+    // Deep clone parents to avoid mutating caller refs
+    const cloned = parents.map(p => ({ ...p }));
+    await walk(root, cloned, spec, 0);
+    return cloned;
+  } catch (e: any) {
+    log.error("loadIncludes error:", e?.message ?? e, e?.stack);
+    // Never throw to the route; return base rows
+    return parents;
+  }
+
+  async function walk(table: TableName, rows: any[], s: any, depth: number): Promise<void> {
+    if (!s || depth >= maxDepth || rows.length === 0) return;
+    const rels: any = (RELATION_GRAPH as any)[table] || {};
+    log.debug("walk", { table, depth, keys: Object.keys(s) });
+
+    // Process each requested relation at this level
+    for (const key of Object.keys(s)) {
+      const rel = rels[key];
+      if (!rel) {
+        log.warn(\`Unknown include key '\${key}' on '\${table}' — skipping\`);
+        continue;
+      }
+      const target = rel.target as TableName;
+
+      // Safely run each loader; never let one bad edge 500 the route
+      if (rel.via) {
+        // M:N via junction
+        try {
+          await loadManyToMany(table, target, rel.via as string, rows, key);
+        } catch (e: any) {
+          log.error("loadManyToMany failed", { table, key, via: rel.via, target }, e?.message ?? e);
+          for (const r of rows) r[key] = [];
+        }
+        // Recurse if nested include specified
+        const childSpec = s[key] && typeof s[key] === "object" ? (s[key] as any).include : undefined;
+        if (childSpec) {
+          const children = rows.flatMap(r => (r[key] ?? []));
+          try {
+            await walk(target, children, childSpec, depth + 1);
+          } catch (e: any) {
+            log.error("walk nested (via) failed", { table: String(target), key }, e?.message ?? e);
+          }
+        }
+        continue;
+      }
+
+      if (rel.kind === "many") {
+        // 1:N target has FK to current
+        try {
+          await loadOneToMany(table, target, rows, key);
+        } catch (e: any) {
+          log.error("loadOneToMany failed", { table, key, target }, e?.message ?? e);
+          for (const r of rows) r[key] = [];
+        }
+        const childSpec = s[key] && typeof s[key] === "object" ? (s[key] as any).include : undefined;
+        if (childSpec) {
+          const children = rows.flatMap(r => (r[key] ?? []));
+          try {
+            await walk(target, children, childSpec, depth + 1);
+          } catch (e: any) {
+            log.error("walk nested (many) failed", { table: String(target), key }, e?.message ?? e);
+          }
+        }
+      } else {
+        // kind === "one"
+        // Could be belongs-to (current has FK to target) OR has-one (target unique-FK to current)
+        const currFks = (FK_INDEX as any)[table] as Array<{from:string[];toTable:string;to:string[]}>;
+        const toTarget = currFks.find(f => f.toTable === target);
+        if (toTarget) {
+          try {
+            await loadBelongsTo(table, target, rows, key);
+          } catch (e: any) {
+            log.error("loadBelongsTo failed", { table, key, target }, e?.message ?? e);
+            for (const r of rows) r[key] = null;
+          }
+        } else {
+          try {
+            await loadHasOne(table, target, rows, key);
+          } catch (e: any) {
+            log.error("loadHasOne failed", { table, key, target }, e?.message ?? e);
+            for (const r of rows) r[key] = null;
+          }
+        }
+        const childSpec = s[key] && typeof s[key] === "object" ? (s[key] as any).include : undefined;
+        if (childSpec) {
+          const children = rows.map(r => r[key]).filter(Boolean);
+          try {
+            await walk(target, children, childSpec, depth + 1);
+          } catch (e: any) {
+            log.error("walk nested (one) failed", { table: String(target), key }, e?.message ?? e);
+          }
+        }
+      }
+    }
+  }
+
+  async function loadBelongsTo(curr: TableName, target: TableName, rows: any[], key: string) {
+    // current has FK cols referencing target PK
+    const fk = (FK_INDEX as any)[curr].find((f: any) => f.toTable === target);
+    if (!fk) { for (const r of rows) r[key] = null; return; }
+    const tuples = distinctTuples(rows, fk.from).filter(t => t.every((v: any) => v != null));
+    if (!tuples.length) { for (const r of rows) r[key] = null; return; }
+
+    // Query target WHERE target.pk IN tuples
+    const pkCols = (PKS as any)[target] as string[];
+    const where = buildOrAndPredicate(pkCols, tuples.length, 1);
+    const params = tuples.flat();
+    const sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
+    log.debug("belongsTo SQL", { curr, target, key, sql, paramsCount: params.length });
+    const { rows: targets } = await pg.query(sql, params);
+
+    const idx = indexByTuple(targets, pkCols);
+    for (const r of rows) {
+      const tup = fk.from.map((c: string) => r[c]);
+      const keyStr = JSON.stringify(tup);
+      r[key] = idx.get(keyStr) ?? null;
+    }
+  }
+
+  async function loadHasOne(curr: TableName, target: TableName, rows: any[], key: string) {
+    // target has FK cols referencing current PK (unique)
+    const fk = (FK_INDEX as any)[target].find((f: any) => f.toTable === curr);
+    if (!fk) { for (const r of rows) r[key] = null; return; }
+
+    const pkCols = (PKS as any)[curr] as string[];
+    const tuples = distinctTuples(rows, pkCols).filter(t => t.every((v: any) => v != null));
+    if (!tuples.length) { for (const r of rows) r[key] = null; return; }
+
+    // SELECT target WHERE fk IN tuples
+    const where = buildOrAndPredicate(fk.from, tuples.length, 1);
+    const params = tuples.flat();
+    const sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
+    log.debug("hasOne SQL", { curr, target, key, sql, paramsCount: params.length });
+    const { rows: targets } = await pg.query(sql, params);
+
+    const idx = indexByTuple(targets, fk.from);
+    for (const r of rows) {
+      const keyStr = JSON.stringify(pkCols.map((c: string) => r[c]));
+      r[key] = idx.get(keyStr) ?? null;
+    }
+  }
+
+  async function loadOneToMany(curr: TableName, target: TableName, rows: any[], key: string) {
+    // target has FK cols referencing current PK
+    const fk = (FK_INDEX as any)[target].find((f: any) => f.toTable === curr);
+    if (!fk) { for (const r of rows) r[key] = []; return; }
+
+    const pkCols = (PKS as any)[curr] as string[];
+    const tuples = distinctTuples(rows, pkCols).filter(t => t.every((v: any) => v != null));
+    if (!tuples.length) { for (const r of rows) r[key] = []; return; }
+
+    const where = buildOrAndPredicate(fk.from, tuples.length, 1);
+    const params = tuples.flat();
+    const sql = \`SELECT * FROM "\${target}" WHERE \${where}\`;
+    log.debug("oneToMany SQL", { curr, target, key, sql, paramsCount: params.length });
+    const { rows: children } = await pg.query(sql, params);
+
+    const groups = groupByTuple(children, fk.from);
+    for (const r of rows) {
+      const keyStr = JSON.stringify(pkCols.map((c: string) => r[c]));
+      r[key] = groups.get(keyStr) ?? [];
+    }
+  }
+
+  async function loadManyToMany(curr: TableName, target: TableName, via: string, rows: any[], key: string) {
+    // via has two FKs: one to curr, one to target
+    const toCurr = (FK_INDEX as any)[via].find((f: any) => f.toTable === curr);
+    const toTarget = (FK_INDEX as any)[via].find((f: any) => f.toTable === target);
+    if (!toCurr || !toTarget) { for (const r of rows) r[key] = []; return; }
+
+    const pkCols = (PKS as any)[curr] as string[];
+    const tuples = distinctTuples(rows, pkCols).filter(t => t.every((v: any) => v != null));
+    if (!tuples.length) { for (const r of rows) r[key] = []; return; }
+
+    // 1) Load junction rows for current parents
+    const whereVia = buildOrAndPredicate(toCurr.from, tuples.length, 1);
+    const sqlVia = \`SELECT * FROM "\${via}" WHERE \${whereVia}\`;
+    const paramsVia = tuples.flat();
+    log.debug("manyToMany junction SQL", { curr, target, via, key, sql: sqlVia, paramsCount: paramsVia.length });
+    const { rows: jrows } = await pg.query(sqlVia, paramsVia);
+
+    if (!jrows.length) { for (const r of rows) r[key] = []; return; }
+
+    // 2) Load targets by distinct target fk tuples in junction
+    const tTuples = distinctTuples(jrows, toTarget.from);
+    const whereT = buildOrAndPredicate((PKS as any)[target], tTuples.length, 1);
+    const sqlT = \`SELECT * FROM "\${target}" WHERE \${whereT}\`;
+    const paramsT = tTuples.flat();
+    log.debug("manyToMany target SQL", { curr, target, via, key, sql: sqlT, paramsCount: paramsT.length });
+    const { rows: targets } = await pg.query(sqlT, paramsT);
+
+    const tIdx = indexByTuple(targets, (PKS as any)[target]);
+
+    // 3) Group junction rows by current pk tuple, map to target rows
+    const byCurr = groupByTuple(jrows, toCurr.from);
+    for (const r of rows) {
+      const currKey = JSON.stringify(pkCols.map((c: string) => r[c]));
+      const j = byCurr.get(currKey) ?? [];
+      r[key] = j.map(jr => tIdx.get(JSON.stringify(toTarget.from.map((c: string) => jr[c])))).filter(Boolean);
+    }
+  }
+}
+`;
+}
+//# sourceMappingURL=emit-include-loader.js.map

package/dist/src/emit-include-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-include-loader.js","sourceRoot":"","sources":["../../src/emit-include-loader.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAY,EAAE,KAAY,EAAE,QAAgB;IAC5E,2CAA2C;IAC3C,MAAM,OAAO,GAQT,EAAE,CAAC;IACP,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5C,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IACvF,CAAC;IAED,OAAO;;;;;;;;;;;;;;;;;mBAiBU,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;cACrC,IAAI,CAAC,SAAS,CACxB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC1E,IAAI,EACJ,CAAC,CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0DoB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgN9B,CAAC;AACF,CAAC"}

package/dist/src/emit-include-spec.d.ts

@@ -0,0 +1,2 @@
+import type { Graph } from "./rel-classify";
+export declare function emitIncludeSpec(graph: Graph): string;

package/dist/src/emit-include-spec.js

@@ -0,0 +1,26 @@
+export function emitIncludeSpec(graph) {
+    let out = `/* Generated. Do not edit. */\n`;
+    const tables = Object.keys(graph);
+    for (const table of tables) {
+        const rels = graph[table] ?? {};
+        const entries = Object.entries(rels);
+        out += `export type ${toPascal(table)}IncludeSpec = {\n`;
+        for (const [relKey, edge] of entries) {
+            if (edge.kind === "many") {
+                out += `  ${relKey}?: boolean | { include?: ${toPascal(edge.target)}IncludeSpec; limit?: number; offset?: number; };\n`;
+            }
+            else {
+                out += `  ${relKey}?: boolean | ${toPascal(edge.target)}IncludeSpec;\n`;
+            }
+        }
+        out += `};\n\n`;
+    }
+    return out;
+}
+function toPascal(s) {
+    return s
+        .split(/[_\s-]+/)
+        .map((w) => (w?.[0] ? w[0].toUpperCase() + w.slice(1) : ""))
+        .join("");
+}
+//# sourceMappingURL=emit-include-spec.js.map

package/dist/src/emit-include-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-include-spec.js","sourceRoot":"","sources":["../../src/emit-include-spec.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,eAAe,CAAC,KAAY;IAC1C,IAAI,GAAG,GAAG,iCAAiC,CAAC;IAE5C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAErC,GAAG,IAAI,eAAe,QAAQ,CAAC,KAAK,CAAC,mBAAmB,CAAC;QACzD,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,OAAO,EAAE,CAAC;YACrC,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBACzB,GAAG,IAAI,KAAK,MAAM,4BAA4B,QAAQ,CACpD,IAAI,CAAC,MAAM,CACZ,oDAAoD,CAAC;YACxD,CAAC;iBAAM,CAAC;gBACN,GAAG,IAAI,KAAK,MAAM,gBAAgB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;YAC1E,CAAC;QACH,CAAC;QACD,GAAG,IAAI,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,QAAQ,CAAC,CAAS;IACzB,OAAO,CAAC;SACL,KAAK,CAAC,SAAS,CAAC;SAChB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SAC3D,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC"}

package/dist/src/emit-logger.d.ts

@@ -0,0 +1 @@
+export declare function emitLogger(): string;

package/dist/src/emit-logger.js

@@ -0,0 +1,35 @@
+/* Emits a tiny logger used by generated server routes. */
+export function emitLogger() {
+    return `/* Generated. Do not edit. */
+const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
+
+export const logger = {
+  debug: (...args: any[]) => { if (DEBUG) console.debug("[sdk:debug]", ...args); },
+  info:  (...args: any[]) => { if (DEBUG) console.info ("[sdk:info ]", ...args); },
+  warn:  (...args: any[]) => {           console.warn ("[sdk:warn ]", ...args); },
+  error: (...args: any[]) => {           console.error("[sdk:error]", ...args); },
+};
+
+export function safe<T extends (c: any) => any>(handler: T) {
+  return async (c: any) => {
+    try {
+      const res = await handler(c);
+      // If a handler returns a Response with 5xx, log the body in debug
+      if (typeof res?.status === "number" && res.status >= 500) {
+        try {
+          const clone = res.clone?.();
+          const text = clone ? await clone.text() : "";
+          logger.error(\`5xx response: \${c.req.method} \${c.req.path}\`, text);
+        } catch {}
+      }
+      return res;
+    } catch (e: any) {
+      logger.error(\`Unhandled error in \${c.req.method} \${c.req.path}\`, e?.stack ?? e);
+      const body = { error: e?.message ?? "Internal error", ...(process.env.SDK_DEBUG ? { stack: e?.stack } : {}) };
+      return c.json(body, 500);
+    }
+  };
+}
+`;
+}
+//# sourceMappingURL=emit-logger.js.map

package/dist/src/emit-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-logger.js","sourceRoot":"","sources":["../../src/emit-logger.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,MAAM,UAAU,UAAU;IACxB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BR,CAAC;AACF,CAAC"}

package/dist/src/emit-routes.d.ts

@@ -0,0 +1,20 @@
+import type { Table } from "./introspect";
+import type { Graph } from "./rel-classify";
+/**
+ * Emits a Hono router for one table, using generated Zod schemas.
+ *
+ * Expects:
+ *   - Generated file at ../zod/<table>.ts exporting Insert<Type>Schema & Update<Type>Schema
+ *   - deps: { pg: Pool | Client } with .query(text, params)
+ *
+ * Endpoints:
+ *   POST   /v1/<table>           create (Insert<Type>Schema)
+ *   GET    /v1/<table>/:...pk    get by pk
+ *   POST   /v1/<table>/list      list (limit/offset; includes)
+ *   PATCH  /v1/<table>/:...pk    update (Update<Type>Schema)
+ *   DELETE /v1/<table>/:...pk    delete (or soft-delete)
+ */
+export declare function emitRoutes(table: Table, _graph: Graph, opts: {
+    softDeleteColumn: string | null;
+    includeDepthLimit: number;
+}): string;

package/dist/src/emit-routes.js

@@ -0,0 +1,208 @@
+import { pascal } from "./utils";
+/**
+ * Emits a Hono router for one table, using generated Zod schemas.
+ *
+ * Expects:
+ *   - Generated file at ../zod/<table>.ts exporting Insert<Type>Schema & Update<Type>Schema
+ *   - deps: { pg: Pool | Client } with .query(text, params)
+ *
+ * Endpoints:
+ *   POST   /v1/<table>           create (Insert<Type>Schema)
+ *   GET    /v1/<table>/:...pk    get by pk
+ *   POST   /v1/<table>/list      list (limit/offset; includes)
+ *   PATCH  /v1/<table>/:...pk    update (Update<Type>Schema)
+ *   DELETE /v1/<table>/:...pk    delete (or soft-delete)
+ */
+export function emitRoutes(table, _graph, opts) {
+    const fileTableName = table.name; // SQL table name for file/route
+    const Type = pascal(table.name); // PascalCase for type/schemas
+    // Normalize pk to an array and fallback to ["id"] if empty
+    const rawPk = table.pk;
+    const pkCols = Array.isArray(rawPk) ? rawPk : rawPk ? [rawPk] : [];
+    const safePkCols = pkCols.length ? pkCols : ["id"];
+    const hasCompositePk = safePkCols.length > 1;
+    const pkPath = hasCompositePk ? safePkCols.map((c) => `:${c}`).join("/") : `:${safePkCols[0]}`;
+    const softDel = opts.softDeleteColumn && table.columns.some((c) => c.name === opts.softDeleteColumn) ? opts.softDeleteColumn : null;
+    // IMPORTANT: interpolate column names at generator time (no escaping/backslashes here)
+    const wherePkSql = hasCompositePk
+        ? safePkCols.map((c, i) => `"${c}" = $${i + 1}`).join(" AND ")
+        : `"${safePkCols[0]}" = $1`;
+    const getPkParams = hasCompositePk
+        ? `const pkValues = [${safePkCols.map((c) => `c.req.param("${c}")`).join(", ")}];`
+        : `const pkValues = [c.req.param("${safePkCols[0]}")];`;
+    // Build SET clause indices for UPDATE (PK params first, then update values)
+    // These strings are emitted into generated code, so we DO escape ${...} intentionally here.
+    const updateSetSql = hasCompositePk
+        ? `Object.keys(updateData).map((k, i) => \`"\${k}" = $\${i + ${safePkCols.length} + 1}\`).join(", ")`
+        : `Object.keys(updateData).map((k, i) => \`"\${k}" = $\${i + 2}\`).join(", ")`;
+    // Prevent updating PK columns
+    const pkFilter = safePkCols.length
+        ? `const updateData = Object.fromEntries(Object.entries(parsed.data).filter(([k]) => !new Set(${JSON.stringify(safePkCols)}).has(k)));`
+        : `const updateData = parsed.data;`;
+    return `/* Generated. Do not edit. */
+import { Hono } from "hono";
+import { z } from "zod";
+import { Insert${Type}Schema, Update${Type}Schema } from "../zod/${fileTableName}";
+import { loadIncludes } from "../include-loader";
+
+const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
+const log = {
+  debug: (...args: any[]) => { if (DEBUG) console.debug("[sdk]", ...args); },
+  error: (...args: any[]) => console.error("[sdk]", ...args),
+};
+
+const listSchema = z.object({
+  include: z.any().optional(),         // TODO: typed include spec in later pass
+  limit: z.number().int().positive().max(100).optional(),
+  offset: z.number().int().min(0).optional(),
+  orderBy: z.any().optional()          // TODO: typed orderBy in a later pass
+});
+
+export function register${Type}Routes(app: Hono, deps: { pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> } }) {
+  const base = "/v1/${fileTableName}";
+
+  // CREATE
+  app.post(base, async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      log.debug("POST ${fileTableName} body:", body);
+      const parsed = Insert${Type}Schema.safeParse(body);
+      if (!parsed.success) {
+        const issues = parsed.error.flatten();
+        log.debug("POST ${fileTableName} invalid:", issues);
+        return c.json({ error: "Invalid body", issues }, 400);
+      }
+
+      const data = parsed.data;
+      const cols = Object.keys(data);
+      const vals = Object.values(data);
+      if (!cols.length) return c.json({ error: "No fields provided" }, 400);
+
+      const placeholders = cols.map((_, i) => '$' + (i + 1)).join(", ");
+      const text = \`INSERT INTO "${fileTableName}" (\${cols.map(c => '"' + c + '"').join(", ")})
+                     VALUES (\${placeholders})
+                     RETURNING *\`;
+      log.debug("SQL:", text, "vals:", vals);
+      const { rows } = await deps.pg.query(text, vals);
+      return c.json(rows[0] ?? null, rows[0] ? 201 : 500);
+    } catch (e: any) {
+      log.error("POST ${fileTableName} error:", e?.stack ?? e);
+      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    }
+  });
+
+  // GET BY PK
+  app.get(\`\${base}/${pkPath}\`, async (c) => {
+    try {
+      ${getPkParams}
+      const text = \`SELECT * FROM "${fileTableName}" WHERE ${wherePkSql} LIMIT 1\`;
+      log.debug("GET ${fileTableName} by PK:", pkValues, "SQL:", text);
+      const { rows } = await deps.pg.query(text, pkValues);
+      if (!rows[0]) return c.json(null, 404);
+      return c.json(rows[0]);
+    } catch (e: any) {
+      log.error("GET ${fileTableName} error:", e?.stack ?? e);
+      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    }
+  });
+
+  // LIST
+  app.post(\`\${base}/list\`, async (c) => {
+    try {
+      const body = listSchema.safeParse(await c.req.json().catch(() => ({})));
+      if (!body.success) {
+        const issues = body.error.flatten();
+        log.debug("LIST ${fileTableName} invalid:", issues);
+        return c.json({ error: "Invalid body", issues }, 400);
+      }
+      const { include, limit = 50, offset = 0 } = body.data;
+
+      const where = ${softDel ? `\`WHERE "${softDel}" IS NULL\`` : `""`};
+      const text = \`SELECT * FROM "${fileTableName}" \${where} LIMIT $1 OFFSET $2\`;
+      log.debug("LIST ${fileTableName} SQL:", text, "params:", [limit, offset]);
+      const { rows } = await deps.pg.query(text, [limit, offset]);
+
+      if (!include) {
+        log.debug("LIST ${fileTableName} rows:", rows.length);
+        return c.json(rows);
+      }
+
+      // Attempt include stitching with explicit error handling
+      log.debug("LIST ${fileTableName} include spec:", include);
+      try {
+        const stitched = await loadIncludes("${fileTableName}", rows, include, deps.pg, ${opts.includeDepthLimit});
+        log.debug("LIST ${fileTableName} stitched count:", Array.isArray(stitched) ? stitched.length : "n/a");
+        return c.json(stitched);
+      } catch (e: any) {
+        const strict = process.env.SDK_STRICT_INCLUDE === "1" || process.env.SDK_STRICT_INCLUDE === "true";
+        const msg = e?.message ?? String(e);
+        const stack = e?.stack;
+        log.error("LIST ${fileTableName} include stitch FAILED:", msg, stack);
+
+        if (strict) {
+          return c.json({ error: "include-stitch-failed", message: msg, ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+        }
+        // Non-strict fallback: return base rows plus error metadata
+        return c.json({ data: rows, includeError: { message: msg, ...(DEBUG ? { stack: e?.stack } : {}) } }, 200);
+      }
+    } catch (e: any) {
+      log.error("LIST ${fileTableName} error:", e?.stack ?? e);
+      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    }
+  });
+
+  // UPDATE
+  app.patch(\`\${base}/${pkPath}\`, async (c) => {
+    try {
+      ${getPkParams}
+      const body = await c.req.json().catch(() => ({}));
+      log.debug("PATCH ${fileTableName} pk:", pkValues, "patch:", body);
+      const parsed = Update${Type}Schema.safeParse(body);
+      if (!parsed.success) {
+        const issues = parsed.error.flatten();
+        log.debug("PATCH ${fileTableName} invalid:", issues);
+        return c.json({ error: "Invalid body", issues: issues }, 400);
+      }
+
+      ${pkFilter}
+      if (!Object.keys(updateData).length) return c.json({ error: "No updatable fields provided" }, 400);
+
+      const setSql = ${updateSetSql};
+      const text = \`UPDATE "${fileTableName}" SET \${setSql} WHERE ${wherePkSql} RETURNING *\`;
+      const params = ${hasCompositePk ? `[...pkValues, ...Object.values(updateData)]` : `[pkValues[0], ...Object.values(updateData)]`};
+      log.debug("PATCH ${fileTableName} SQL:", text, "params:", params);
+      const { rows } = await deps.pg.query(text, params);
+      if (!rows[0]) return c.json(null, 404);
+      return c.json(rows[0]);
+    } catch (e: any) {
+      log.error("PATCH ${fileTableName} error:", e?.stack ?? e);
+      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    }
+  });
+
+  // DELETE (soft or hard)
+  app.delete(\`\${base}/${pkPath}\`, async (c) => {
+    try {
+      ${getPkParams}
+      ${softDel
+        ? `
+      const text = \`UPDATE "${fileTableName}" SET "${softDel}" = NOW() WHERE ${wherePkSql} RETURNING *\`;
+      log.debug("DELETE (soft) ${fileTableName} SQL:", text, "pk:", pkValues);
+      const { rows } = await deps.pg.query(text, pkValues);
+      if (!rows[0]) return c.json(null, 404);
+      return c.json(rows[0]);`
+        : `
+      const text = \`DELETE FROM "${fileTableName}" WHERE ${wherePkSql} RETURNING *\`;
+      log.debug("DELETE ${fileTableName} SQL:", text, "pk:", pkValues);
+      const { rows } = await deps.pg.query(text, pkValues);
+      if (!rows[0]) return c.json(null, 404);
+      return c.json(rows[0]);`}
+    } catch (e: any) {
+      log.error("DELETE ${fileTableName} error:", e?.stack ?? e);
+      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    }
+  });
+}
+`;
+}
+//# sourceMappingURL=emit-routes.js.map

package/dist/src/emit-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-routes.js","sourceRoot":"","sources":["../../src/emit-routes.ts"],"names":[],"mappings":"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"}

package/dist/src/emit-types.d.ts

@@ -0,0 +1,5 @@
+import type { Table } from "./introspect";
+export declare function emitTypes(table: Table, opts: {
+    dateType: "date" | "string";
+    numericMode: "string" | "number";
+}): string;