postgresdk 0.18.1 → 0.18.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js.map

@@ -1 +0,0 @@
-{"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/core/operations.d.ts

@@ -1,68 +0,0 @@
-/**
- * Core database operations that are framework-agnostic.
- * These functions handle the actual database logic and can be used by any framework adapter.
- */
-export interface DatabaseClient {
-    query: (text: string, params?: any[]) => Promise<{
-        rows: any[];
-    }>;
-}
-export interface OperationContext {
-    pg: DatabaseClient;
-    table: string;
-    pkColumns: string[];
-    softDeleteColumn?: string | null;
-    includeMethodsDepth: number;
-}
-/**
- * CREATE operation - Insert a new record
- */
-export declare function createRecord(ctx: OperationContext, data: Record<string, any>): Promise<{
-    data?: any;
-    error?: string;
-    issues?: any;
-    status: number;
-}>;
-/**
- * READ operation - Get a record by primary key
- */
-export declare function getByPk(ctx: OperationContext, pkValues: any[]): Promise<{
-    data?: any;
-    error?: string;
-    status: number;
-}>;
-/**
- * LIST operation - Get multiple records with optional filters
- */
-export declare function listRecords(ctx: OperationContext, params: {
-    where?: any;
-    limit?: number;
-    offset?: number;
-    include?: any;
-    orderBy?: string | string[];
-    order?: "asc" | "desc" | ("asc" | "desc")[];
-}): Promise<{
-    data?: any;
-    error?: string;
-    issues?: any;
-    needsIncludes?: boolean;
-    includeSpec?: any;
-    status: number;
-}>;
-/**
- * UPDATE operation - Update a record by primary key
- */
-export declare function updateRecord(ctx: OperationContext, pkValues: any[], updateData: Record<string, any>): Promise<{
-    data?: any;
-    error?: string;
-    issues?: any;
-    status: number;
-}>;
-/**
- * DELETE operation - Delete or soft-delete a record by primary key
- */
-export declare function deleteRecord(ctx: OperationContext, pkValues: any[]): Promise<{
-    data?: any;
-    error?: string;
-    status: number;
-}>;

package/dist/emit-api-contract.d.ts

@@ -1,60 +0,0 @@
-import type { Model } from "./introspect";
-import type { Config, AuthConfig } from "./types";
-export interface ApiContract {
-    version: string;
-    generatedAt: string;
-    description: string;
-    authentication?: {
-        type: string;
-        description: string;
-    };
-    resources: ResourceContract[];
-    relationships: RelationshipContract[];
-}
-export interface ResourceContract {
-    name: string;
-    tableName: string;
-    description: string;
-    endpoints: EndpointContract[];
-    fields: FieldContract[];
-}
-export interface EndpointContract {
-    method: string;
-    path: string;
-    description: string;
-    requestBody?: any;
-    responseBody?: any;
-    queryParameters?: any;
-}
-export interface FieldContract {
-    name: string;
-    type: string;
-    required: boolean;
-    description: string;
-    foreignKey?: {
-        table: string;
-        field: string;
-    };
-}
-export interface RelationshipContract {
-    from: string;
-    to: string;
-    type: "one-to-many" | "many-to-one" | "many-to-many";
-    description: string;
-}
-/**
- * Generate a comprehensive API contract in JSON format
- */
-export declare function generateApiContract(model: Model, config: Config & {
-    auth?: AuthConfig;
-}): ApiContract;
-/**
- * Generate a human-readable markdown version of the contract
- */
-export declare function generateApiContractMarkdown(contract: ApiContract): string;
-/**
- * Emit the API contract as TypeScript code that can be served as an endpoint
- */
-export declare function emitApiContract(model: Model, config: Config & {
-    auth?: AuthConfig;
-}): string;

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

@@ -1 +0,0 @@
-{"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

@@ -1,114 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,30 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,299 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

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