postgresdk 0.1.1-alpha.0

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,2BAA2B;AAC3B,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACtC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;AAC1F,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;AAEpC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEnC,mBAAmB;AACnB,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;IACtD,OAAO,CAAC,GAAG,CAAC,eAAe,OAAO,EAAE,CAAC,CAAC;IACtC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,gBAAgB;AAChB,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;IACnD,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;CAUb,CAAC,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,kBAAkB;AAClB,IAAI,UAAU,GAAG,sBAAsB,CAAC;AACxC,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,UAAU,CAAC,CAAC;AACxE,IAAI,WAAW,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC;IAChD,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,CAAC,CAAE,CAAC;AACtC,CAAC;AAED,gBAAgB;AAChB,IAAI,CAAC;IACH,MAAM,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC;AACrD,CAAC;AAAC,OAAO,GAAG,EAAE,CAAC;IACb,OAAO,CAAC,KAAK,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC;IAC3C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC"}

package/dist/emit-client.d.ts

@@ -0,0 +1,3 @@
+import type { Table } from "./introspect";
+export declare function emitClient(table: Table): string;
+export declare function emitClientIndex(tables: Table[]): string;

package/dist/emit-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-client.d.ts","sourceRoot":"","sources":["../src/emit-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,UA8FtC;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,UAmB9C"}

package/dist/emit-client.js

@@ -0,0 +1,114 @@
+import { pascal } from "./utils";
+export function emitClient(table) {
+    const Type = pascal(table.name);
+    // Normalize PKs
+    const pkCols = Array.isArray(table.pk)
+        ? table.pk
+        : table.pk
+            ? [table.pk]
+            : [];
+    const safePk = pkCols.length ? pkCols : ["id"];
+    const hasCompositePk = safePk.length > 1;
+    const pkType = hasCompositePk ? `{ ${safePk.map((c) => `${c}: string`).join("; ")} }` : `string`;
+    const pkPathExpr = hasCompositePk ? safePk.map((c) => `pk.${c}`).join(` + "/" + `) : `pk`;
+    return `/* Generated. Do not edit. */
+import type { ${Type}IncludeSpec } from "./include-spec";
+import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}";
+
+export class ${Type}Client {
+  constructor(
+    private baseUrl: string,
+    private fetchFn: typeof fetch = fetch,
+    private auth?: () => Promise<Record<string,string>>
+  ) {}
+
+  private async headers(json = false) {
+    const extra = (await this.auth?.()) ?? {};
+    return json ? { "Content-Type": "application/json", ...extra } : extra;
+  }
+
+  private async okOrThrow(res: Response, action: string) {
+    if (!res.ok) {
+      let detail = "";
+      try { detail = await res.text(); } catch {}
+      throw new Error(\`\${action} ${table.name} failed: \${res.status} \${detail}\`);
+    }
+  }
+
+  async create(data: Insert${Type}): Promise<Select${Type}> {
+    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}\`, {
+      method: "POST",
+      headers: await this.headers(true),
+      body: JSON.stringify(data),
+    });
+    await this.okOrThrow(res, "create");
+    return (await res.json()) as Select${Type};
+  }
+
+  async getByPk(pk: ${pkType}): Promise<Select${Type} | null> {
+    const path = ${pkPathExpr};
+    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/\${path}\`, {
+      headers: await this.headers(),
+    });
+    if (res.status === 404) return null;
+    await this.okOrThrow(res, "get");
+    return (await res.json()) as Select${Type};
+  }
+
+  async list(params?: { include?: ${Type}IncludeSpec; limit?: number; offset?: number }): Promise<Select${Type}[]> {
+    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/list\`, {
+      method: "POST",
+      headers: await this.headers(true),
+      body: JSON.stringify(params ?? {}),
+    });
+    await this.okOrThrow(res, "list");
+    return (await res.json()) as Select${Type}[];
+  }
+
+  async update(pk: ${pkType}, patch: Update${Type}): Promise<Select${Type} | null> {
+    const path = ${pkPathExpr};
+    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/\${path}\`, {
+      method: "PATCH",
+      headers: await this.headers(true),
+      body: JSON.stringify(patch),
+    });
+    if (res.status === 404) return null;
+    await this.okOrThrow(res, "update");
+    return (await res.json()) as Select${Type};
+  }
+
+  async delete(pk: ${pkType}): Promise<Select${Type} | null> {
+    const path = ${pkPathExpr};
+    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/\${path}\`, {
+      method: "DELETE",
+      headers: await this.headers(),
+    });
+    if (res.status === 404) return null;
+    await this.okOrThrow(res, "delete");
+    return (await res.json()) as Select${Type};
+  }
+}
+`;
+}
+export function emitClientIndex(tables) {
+    let out = `/* Generated. Do not edit. */\n`;
+    for (const t of tables) {
+        out += `import { ${pascal(t.name)}Client } from "./${t.name}";\n`;
+    }
+    out += `\nexport class SDK {\n`;
+    for (const t of tables) {
+        out += `  public ${t.name}: ${pascal(t.name)}Client;\n`;
+    }
+    out += `\n  constructor(cfg: { baseUrl: string; fetch?: typeof fetch; auth?: () => Promise<Record<string,string>> }) {\n`;
+    out += `    const f = cfg.fetch ?? fetch;\n`;
+    for (const t of tables) {
+        out += `    this.${t.name} = new ${pascal(t.name)}Client(cfg.baseUrl, f, cfg.auth);\n`;
+    }
+    out += `  }\n`;
+    out += `}\n`;
+    for (const t of tables)
+        out += `export { ${pascal(t.name)}Client } from "./${t.name}";\n`;
+    out += `export * from "./include-spec";\n`;
+    return out;
+}
+//# sourceMappingURL=emit-client.js.map

package/dist/emit-client.js.map

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

package/dist/emit-include-builder.d.ts

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

package/dist/emit-include-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-include-builder.d.ts","sourceRoot":"","sources":["../src/emit-include-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UA4BhE"}

package/dist/emit-include-builder.js

@@ -0,0 +1,30 @@
+export function emitIncludeBuilder(graph, maxDepth) {
+    return `// Generated. Do not edit.
+export const RELATION_GRAPH = ${JSON.stringify(graph, null, 2)} as const;
+type TableName = keyof typeof RELATION_GRAPH;
+
+export function buildWith(root: TableName, spec: any, maxDepth = ${maxDepth}) {
+  return walk(root as string, spec, 0);
+  function walk(table: string, s: any, depth: number): any {
+    if (!s || depth >= maxDepth) return undefined;
+    const rels: any = (RELATION_GRAPH as any)[table] || {};
+    const out: any = {};
+    for (const key of Object.keys(s)) {
+      const rel = rels[key];
+      if (!rel) throw new Error(\`Unknown include key '\${key}' on table '\${table}'\`);
+      const v = s[key];
+      if (v === true) out[key] = true;
+      else if (v && typeof v === "object") {
+        const child = "include" in v ? walk(rel.target, v.include, depth + 1) : undefined;
+        out[key] = child ? { with: child } : true;
+      }
+    }
+    return Object.keys(out).length ? out : undefined;
+  }
+}
+
+export const buildWithFor = (t: TableName) =>
+  (spec?: any, depth = ${maxDepth}) => (spec ? buildWith(t, spec, depth) : undefined);
+`;
+}
+//# sourceMappingURL=emit-include-builder.js.map

package/dist/emit-include-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-include-builder.js","sourceRoot":"","sources":["../src/emit-include-builder.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,kBAAkB,CAAC,KAAY,EAAE,QAAgB;IAC/D,OAAO;gCACuB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;;;mEAGK,QAAQ;;;;;;;;;;;;;;;;;;;;;yBAqBlD,QAAQ;CAChC,CAAC;AACF,CAAC"}

package/dist/emit-include-loader.d.ts

@@ -0,0 +1,9 @@
+import type { Graph } from "./rel-classify";
+import type { Model } from "./introspect";
+/**
+ * Emit a generic include loader that:
+ * - Walks the include spec
+ * - Loads children in batches per edge kind
+ * - Stitches onto parent rows (mutates copies)
+ */
+export declare function emitIncludeLoader(graph: Graph, model: Model, maxDepth: number): string;

package/dist/emit-include-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-include-loader.d.ts","sourceRoot":"","sources":["../src/emit-include-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAgT7E"}

package/dist/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/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/emit-include-spec.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit-include-spec.d.ts","sourceRoot":"","sources":["../src/emit-include-spec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,UAsB3C"}

package/dist/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/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/emit-logger.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit-logger.d.ts","sourceRoot":"","sources":["../src/emit-logger.ts"],"names":[],"mappings":"AACA,wBAAgB,UAAU,WAgCzB"}

package/dist/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/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/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/emit-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-routes.d.ts","sourceRoot":"","sources":["../src/emit-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAG5C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,KAAK,EACb,IAAI,EAAE;IAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,UA+MrE"}