equipped 5.2.9 → 5.3.0

package/dist/types/orm/adapters/postgresql/index.js

@@ -0,0 +1,2069 @@
+import {
+  Filter,
+  FilterGroup,
+  IncOp,
+  MaxOp,
+  MinOp,
+  MulOp,
+  OrmAdapter,
+  OrmValidationError,
+  PatchOp,
+  PullOp,
+  PushOp,
+  UnsetOp,
+  flattenOps
+} from "../../../chunk-JQ2FWX4W.js";
+import {
+  EquippedError,
+  configurable
+} from "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/orm/adapters/postgresql/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { Pool } from "pg";
+import Cursor from "pg-cursor";
+import { v } from "valleyed";
+
+// src/orm/adapters/postgresql/query.ts
+function mapField(field, primaryKey) {
+  if (field === "id" && primaryKey !== "id") return primaryKey;
+  return field;
+}
+function compileOps(f, field, nextParam) {
+  switch (f.op) {
+    case "eq":
+      return f.value === null ? `${field} IS NULL` : `${field} = ${nextParam(f.value)}`;
+    case "ne":
+      return f.value === null ? `${field} IS NOT NULL` : `${field} != ${nextParam(f.value)}`;
+    case "gt":
+      return `${field} > ${nextParam(f.value)}`;
+    case "gte":
+      return `${field} >= ${nextParam(f.value)}`;
+    case "lt":
+      return `${field} < ${nextParam(f.value)}`;
+    case "lte":
+      return `${field} <= ${nextParam(f.value)}`;
+    case "in":
+      return `${field} = ANY(${nextParam(f.value)})`;
+    case "notIn":
+      return `NOT (${field} = ANY(${nextParam(f.value)}))`;
+    case "like":
+      return `${field} ILIKE ${nextParam(`%${f.value}%`)}`;
+    case "exists":
+      return `${field} IS NOT NULL`;
+    case "notExists":
+      return `${field} IS NULL`;
+    case "contains":
+      return `${field} @> ${nextParam(JSON.stringify(f.value))}::jsonb`;
+    case "notContains":
+      return `NOT (${field} @> ${nextParam(JSON.stringify(f.value))}::jsonb)`;
+    default:
+      return `${field} = ${nextParam(f.value)}`;
+  }
+}
+function compileFilter(f, primaryKey, nextParam) {
+  return compileOps(f, `"${mapField(f.field, primaryKey)}"`, nextParam);
+}
+function compileChildren(group, compileLeaf) {
+  return group.children.map((c) => compileChild(c, compileLeaf)).filter((c) => c !== null);
+}
+function compileGroup(group, compileLeaf) {
+  const parts = compileChildren(group, compileLeaf);
+  if (parts.length === 0) return null;
+  if (parts.length === 1) return parts[0];
+  return `(${parts.join(group.op === "or" ? " OR " : " AND ")})`;
+}
+function compileChild(child, compileLeaf) {
+  if (child instanceof Filter) return compileLeaf(child);
+  if (child instanceof FilterGroup) return compileGroup(child, compileLeaf);
+  return null;
+}
+function compilePgFilter(group, primaryKey, startIndex = 1) {
+  const params = [];
+  let paramIndex = startIndex;
+  function nextParam(value) {
+    params.push(value);
+    return `$${paramIndex++}`;
+  }
+  const leaf = (f) => compileFilter(f, primaryKey, nextParam);
+  const whereParts = compileChildren(group, leaf);
+  const whereClause = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+  return { whereClause, params, nextParamIndex: paramIndex };
+}
+function buildSetParts(data, startIndex) {
+  const params = [];
+  let paramIndex = startIndex;
+  const setParts = Object.entries(data).map(([key, value]) => {
+    const col = `"${key}"`;
+    if (value instanceof IncOp) {
+      params.push(value.value);
+      return `${col} = ${col} + $${paramIndex++}`;
+    }
+    if (value instanceof MulOp) {
+      params.push(value.value);
+      return `${col} = ${col} * $${paramIndex++}`;
+    }
+    if (value instanceof MinOp) {
+      params.push(value.value);
+      return `${col} = LEAST(${col}, $${paramIndex++})`;
+    }
+    if (value instanceof MaxOp) {
+      params.push(value.value);
+      return `${col} = GREATEST(${col}, $${paramIndex++})`;
+    }
+    if (value instanceof UnsetOp) {
+      return `${col} = NULL`;
+    }
+    if (value instanceof PushOp) {
+      params.push(JSON.stringify(value.value));
+      return `${col} = ${col} || jsonb_build_array($${paramIndex++}::jsonb)`;
+    }
+    if (value instanceof PullOp) {
+      params.push(JSON.stringify(value.value));
+      return `${col} = (SELECT COALESCE(jsonb_agg(e), '[]'::jsonb) FROM jsonb_array_elements(${col}) e WHERE e <> $${paramIndex++}::jsonb)`;
+    }
+    if (value instanceof PatchOp) {
+      params.push(JSON.stringify(value.value));
+      return `${col} = ${col} || $${paramIndex++}::jsonb`;
+    }
+    params.push(value);
+    return `${col} = $${paramIndex++}`;
+  });
+  return { setParts, params, nextParamIndex: paramIndex };
+}
+function buildSelectQuery(group, options, tableName, primaryKey) {
+  const { whereClause, params, nextParamIndex } = compilePgFilter(group, primaryKey);
+  let i = nextParamIndex;
+  const orderParts = (options?.orderBy ?? []).map((o) => `"${mapField(o.field, primaryKey)}" ${o.direction.toUpperCase()}`);
+  const orderClause = orderParts.length > 0 ? `ORDER BY ${orderParts.join(", ")}` : "";
+  let limitClause = "";
+  if (options?.limit != null) {
+    params.push(options.limit);
+    limitClause = `LIMIT $${i++}`;
+  }
+  let offsetClause = "";
+  if (options?.offset != null) {
+    params.push(options.offset);
+    offsetClause = `OFFSET $${i++}`;
+  }
+  const selectClause = options?.select?.length ? options.select.map((f) => `"${mapField(f, primaryKey)}"`).join(", ") : "*";
+  const sql = `SELECT ${selectClause} FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause} ${offsetClause}`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildCountQuery(group, tableName, primaryKey) {
+  const { whereClause, params } = compilePgFilter(group, primaryKey);
+  const sql = `SELECT COUNT(*) as count FROM "${tableName}" ${whereClause}`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildCreateQuery(tableName, data) {
+  const keys = Object.keys(data);
+  const params = Object.values(data);
+  const placeholders = keys.map((_, i) => `$${i + 1}`);
+  const columns = keys.map((k) => `"${k}"`).join(", ");
+  const sql = `INSERT INTO "${tableName}" (${columns}) VALUES (${placeholders.join(", ")}) RETURNING *`;
+  return { sql, params };
+}
+function buildUpdateQuery(group, tableName, primaryKey, data) {
+  const { setParts, params: setParams, nextParamIndex } = buildSetParts(data, 1);
+  const { whereClause, params: whereParams } = compilePgFilter(group, primaryKey, nextParamIndex);
+  const params = [...setParams, ...whereParams];
+  const sql = `UPDATE "${tableName}" SET ${setParts.join(", ")} ${whereClause} RETURNING *`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildPkUpdateQuery(tableName, primaryKey, pk, data) {
+  const { setParts, params: setParams, nextParamIndex } = buildSetParts(data, 1);
+  setParams.push(pk);
+  const sql = `UPDATE "${tableName}" SET ${setParts.join(", ")} WHERE "${primaryKey}" = $${nextParamIndex} RETURNING *`.replace(
+    /\s+/g,
+    " "
+  );
+  return { sql, params: setParams };
+}
+function buildDeleteQuery(group, tableName, primaryKey) {
+  const { whereClause, params } = compilePgFilter(group, primaryKey);
+  const sql = `DELETE FROM "${tableName}" ${whereClause} RETURNING *`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildUpsertQuery(tableName, conflictColumn, primaryKey, create, data) {
+  const columns = Object.keys(create);
+  const createParams = Object.values(create);
+  const placeholders = columns.map((_, i) => `$${i + 1}`);
+  const pgConflictCol = mapField(conflictColumn, primaryKey);
+  let setClause;
+  const allParams = [...createParams];
+  if (Object.keys(data).length > 0) {
+    const { setParts, params: setParams } = buildSetParts(data, columns.length + 1);
+    setClause = setParts.join(", ");
+    allParams.push(...setParams);
+  } else {
+    setClause = `"${pgConflictCol}" = EXCLUDED."${pgConflictCol}"`;
+  }
+  const sql = `INSERT INTO "${tableName}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT ("${pgConflictCol}") DO UPDATE SET ${setClause} RETURNING *`.replace(
+    /\s+/g,
+    " "
+  );
+  return { sql, params: allParams };
+}
+function extractUpsertConflictColumn(filter, schemaName) {
+  if (filter.children.length === 1 && filter.children[0] instanceof Filter && filter.children[0].op === "eq") {
+    return filter.children[0].field;
+  }
+  let description;
+  if (filter.children.length === 0) {
+    description = "empty filter";
+  } else if (filter.children.length === 1) {
+    const child = filter.children[0];
+    const opDesc = child instanceof Filter ? child.op : "group";
+    description = `single non-eq filter (op: ${opDesc})`;
+  } else {
+    description = `${filter.children.length} filter clauses`;
+  }
+  throw new OrmValidationError("upsert-filter-incompatible", schemaName, "upsertOne", [
+    {
+      cause: `PostgreSQL upsert requires a single eq filter on a UNIQUE-indexed column; received ${description}`
+    }
+  ]);
+}
+function aggFnToSql(fn, field, primaryKey) {
+  if (fn === "count") return "COUNT(*)";
+  const col = `"${mapField(field, primaryKey)}"`;
+  switch (fn) {
+    case "countDistinct":
+      return `COUNT(DISTINCT ${col})`;
+    case "sum":
+      return `SUM(${col})`;
+    case "avg":
+      return `AVG(${col})`;
+    case "min":
+      return `MIN(${col})`;
+    case "max":
+      return `MAX(${col})`;
+  }
+}
+function resolveHavingField(field, primaryKey, aliasToExpr, groupBySet) {
+  if (aliasToExpr.has(field)) return aliasToExpr.get(field);
+  if (groupBySet.has(field)) return `"${mapField(field, primaryKey)}"`;
+  return `"${field}"`;
+}
+function buildAggregateQuery(spec, tableName, primaryKey) {
+  const params = [];
+  let paramIndex = 1;
+  function nextParam(value) {
+    params.push(value);
+    return `$${paramIndex++}`;
+  }
+  const selectParts = [];
+  const aliasToExpr = /* @__PURE__ */ new Map();
+  for (const agg of spec.aggregates) {
+    const expr = aggFnToSql(agg.fn, agg.field, primaryKey);
+    aliasToExpr.set(agg.alias, expr);
+    selectParts.push(`${expr} AS "${agg.alias}"`);
+  }
+  const groupByFields = [];
+  for (const f of spec.groupBy) {
+    const col = `"${mapField(f, primaryKey)}"`;
+    groupByFields.push(col);
+    selectParts.push(`${col} AS "${f}"`);
+  }
+  let whereClause = "";
+  if (spec.where) {
+    const whereLeaf = (f) => compileFilter(f, primaryKey, nextParam);
+    const whereParts = compileChildren(spec.where, whereLeaf);
+    if (whereParts.length > 0) whereClause = `WHERE ${whereParts.join(" AND ")}`;
+  }
+  const groupByClause = groupByFields.length > 0 ? `GROUP BY ${groupByFields.join(", ")}` : "";
+  let havingClause = "";
+  if (spec.having) {
+    const groupBySet = new Set(spec.groupBy);
+    const havingLeaf = (f) => compileOps(f, resolveHavingField(f.field, primaryKey, aliasToExpr, groupBySet), nextParam);
+    const havingParts = compileChildren(spec.having, havingLeaf);
+    if (havingParts.length > 0) havingClause = `HAVING ${havingParts.join(" AND ")}`;
+  }
+  const sql = `SELECT ${selectParts.join(", ")} FROM "${tableName}" ${whereClause} ${groupByClause} ${havingClause}`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { FilterGroup: FilterGroup2 } = await null;
+  const { OrderBy } = await null;
+  const { IncOp: IncOp2, MulOp: MulOp2, MinOp: MinOp2, MaxOp: MaxOp2, UnsetOp: UnsetOp2, PushOp: PushOp2, PullOp: PullOp2, PatchOp: PatchOp2, SetOp, flattenOps: flattenOps2 } = await null;
+  const { OrmValidationError: OrmValidationError2 } = await null;
+  describe("compilePgFilter", () => {
+    test("empty filter group compiles to empty WHERE clause", () => {
+      const group = FilterGroup2.create();
+      const { sql } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users"');
+    });
+    test("single eq filter compiles to WHERE field = $1", () => {
+      const group = FilterGroup2.create().eq("name", "Alice");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "name" = $1');
+      expect(params).toEqual(["Alice"]);
+    });
+    test("eq with null compiles to IS NULL", () => {
+      const group = FilterGroup2.create().eq("name", null);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "name" IS NULL');
+      expect(params).toEqual([]);
+    });
+    test("ne compiles to != (or IS NOT NULL for null)", () => {
+      const group = FilterGroup2.create().ne("age", 5);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "age" != $1');
+      expect(params).toEqual([5]);
+      const nullGroup = FilterGroup2.create().ne("age", null);
+      const { sql: nullSql } = buildSelectQuery(nullGroup, void 0, "users", "id");
+      expect(nullSql).toBe('SELECT * FROM "users" WHERE "age" IS NOT NULL');
+    });
+    test("gt, gte, lt, lte compile to >, >=, <, <=", () => {
+      expect(buildSelectQuery(FilterGroup2.create().gt("age", 10), void 0, "t", "id").sql).toContain('"age" > $1');
+      expect(buildSelectQuery(FilterGroup2.create().gte("age", 20), void 0, "t", "id").sql).toContain('"age" >= $1');
+      expect(buildSelectQuery(FilterGroup2.create().lt("age", 30), void 0, "t", "id").sql).toContain('"age" < $1');
+      expect(buildSelectQuery(FilterGroup2.create().lte("age", 40), void 0, "t", "id").sql).toContain('"age" <= $1');
+    });
+    test("in compiles to = ANY($N)", () => {
+      const group = FilterGroup2.create().in("status", ["a", "b"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"status" = ANY($1)');
+      expect(params).toEqual([["a", "b"]]);
+    });
+    test("notIn compiles to NOT (field = ANY($N)) \u2014 canonical name notIn", () => {
+      const group = FilterGroup2.create().notIn("status", ["x", "y"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('NOT ("status" = ANY($1))');
+      expect(params).toEqual([["x", "y"]]);
+    });
+    test("like compiles to ILIKE with % wrapping", () => {
+      const group = FilterGroup2.create().like("name", "ali");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"name" ILIKE $1');
+      expect(params).toEqual(["%ali%"]);
+    });
+    test("exists compiles to IS NOT NULL (own op, not boolean form)", () => {
+      const group = FilterGroup2.create().exists("val");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"val" IS NOT NULL');
+      expect(params).toEqual([]);
+    });
+    test("notExists is its own op \u2014 compiles to IS NULL", () => {
+      const group = FilterGroup2.create().notExists("val");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"val" IS NULL');
+      expect(params).toEqual([]);
+    });
+    test("contains compiles to @> jsonb", () => {
+      const group = FilterGroup2.create().contains("tags", ["a", "b"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"tags" @> $1::jsonb');
+      expect(params).toEqual([JSON.stringify(["a", "b"])]);
+    });
+    test("notContains compiles to NOT (@> jsonb)", () => {
+      const group = FilterGroup2.create().notContains("tags", ["x"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('NOT ("tags" @> $1::jsonb)');
+      expect(params).toEqual([JSON.stringify(["x"])]);
+    });
+    test("multiple clauses produce AND-joined WHERE", () => {
+      const group = FilterGroup2.create().eq("a", 1).gt("b", 2);
+      const { sql } = buildSelectQuery(group, void 0, "t", "id");
+      expect(sql).toContain('WHERE "a" = $1 AND "b" > $2');
+    });
+    test("nested and/or groups compile correctly", () => {
+      const group = FilterGroup2.create().and([
+        (q) => q.eq("a", 1),
+        (q) => q.or([(g) => g.eq("b", 2), (g) => g.eq("c", 3)])
+      ]);
+      const { sql, params } = buildSelectQuery(group, void 0, "t", "id");
+      expect(sql).toContain('("a" = $1 AND ("b" = $2 OR "c" = $3))');
+      expect(params).toEqual([1, 2, 3]);
+    });
+    test("maps id field to primaryKey when primaryKey differs", () => {
+      const group = FilterGroup2.create().eq("id", "abc");
+      const { sql } = buildSelectQuery(group, void 0, "users", "user_id");
+      expect(sql).toContain('"user_id" = $1');
+    });
+  });
+  describe("buildSelectQuery", () => {
+    test("options: sort, limit, offset, select", () => {
+      const group = FilterGroup2.create().eq("active", true);
+      const options = {
+        orderBy: [new OrderBy("name", "asc"), new OrderBy("age", "desc")],
+        limit: 10,
+        offset: 5,
+        select: ["name", "age"]
+      };
+      const { sql, params } = buildSelectQuery(group, options, "users", "id");
+      expect(sql).toContain('SELECT "name", "age"');
+      expect(sql).toContain('ORDER BY "name" ASC, "age" DESC');
+      expect(sql).toContain("LIMIT $2");
+      expect(sql).toContain("OFFSET $3");
+      expect(params).toEqual([true, 10, 5]);
+    });
+    test("undefined options returns basic SELECT *", () => {
+      const group = FilterGroup2.create().eq("x", 1);
+      const { sql } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "x" = $1');
+    });
+  });
+  describe("buildCreateQuery", () => {
+    test("produces INSERT with RETURNING *", () => {
+      const { sql, params } = buildCreateQuery("users", { name: "Alice", age: 30 });
+      expect(sql).toBe('INSERT INTO "users" ("name", "age") VALUES ($1, $2) RETURNING *');
+      expect(params).toEqual(["Alice", 30]);
+    });
+  });
+  describe("buildUpdateQuery", () => {
+    test("plain values produce SET col = $N", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql, params } = buildUpdateQuery(group, "users", "id", { name: "Bob", age: 25 });
+      expect(sql).toBe('UPDATE "users" SET "name" = $1, "age" = $2 WHERE "id" = $3 RETURNING *');
+      expect(params).toEqual(["Bob", 25, "u1"]);
+    });
+    test("IncOp produces col = col + $N", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql, params } = buildUpdateQuery(group, "users", "id", { count: new IncOp2("count", 5) });
+      expect(sql).toContain('"count" = "count" + $1');
+      expect(params[0]).toBe(5);
+    });
+    test("MulOp produces col = col * $N", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { score: new MulOp2("score", 2) });
+      expect(sql).toContain('"score" = "score" * $1');
+    });
+    test("MinOp/MaxOp produce LEAST/GREATEST", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", {
+        lo: new MinOp2("lo", 1),
+        hi: new MaxOp2("hi", 99)
+      });
+      expect(sql).toContain('LEAST("lo", $1)');
+      expect(sql).toContain('GREATEST("hi", $2)');
+    });
+    test("UnsetOp produces col = NULL", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { old: new UnsetOp2("old") });
+      expect(sql).toContain('"old" = NULL');
+    });
+    test("PushOp produces jsonb array append", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { tags: new PushOp2("tags", "new") });
+      expect(sql).toContain("jsonb_build_array($1::jsonb)");
+    });
+    test("PullOp produces jsonb array removal", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { tags: new PullOp2("tags", "old") });
+      expect(sql).toContain("jsonb_array_elements");
+    });
+    test("PatchOp produces jsonb merge", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { meta: new PatchOp2("meta", { a: 1 }) });
+      expect(sql).toContain("|| $1::jsonb");
+    });
+  });
+  describe("buildPkUpdateQuery", () => {
+    test("builds UPDATE with PK WHERE clause", () => {
+      const { sql, params } = buildPkUpdateQuery("users", "id", "u1", { name: "Bob" });
+      expect(sql).toBe('UPDATE "users" SET "name" = $1 WHERE "id" = $2 RETURNING *');
+      expect(params).toEqual(["Bob", "u1"]);
+    });
+    test("handles ops in PK update", () => {
+      const { sql, params } = buildPkUpdateQuery("users", "id", "u1", { count: new IncOp2("count", 3) });
+      expect(sql).toContain('"count" = "count" + $1');
+      expect(sql).toContain('WHERE "id" = $2');
+      expect(params).toEqual([3, "u1"]);
+    });
+  });
+  describe("buildDeleteQuery", () => {
+    test("produces DELETE with RETURNING *", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql, params } = buildDeleteQuery(group, "users", "id");
+      expect(sql).toBe('DELETE FROM "users" WHERE "id" = $1 RETURNING *');
+      expect(params).toEqual(["u1"]);
+    });
+  });
+  describe("buildUpsertQuery", () => {
+    test("produces INSERT ON CONFLICT with SET parts from data", () => {
+      const data = flattenOps2([new SetOp({ name: "Updated" })]);
+      const { sql, params } = buildUpsertQuery("users", "email", "id", { id: "u1", email: "a@b.com", name: "Alice" }, data);
+      expect(sql).toContain('INSERT INTO "users"');
+      expect(sql).toContain('ON CONFLICT ("email") DO UPDATE SET');
+      expect(sql).toContain('"name" = $4');
+      expect(sql).toContain("RETURNING *");
+      expect(params).toEqual(["u1", "a@b.com", "Alice", "Updated"]);
+    });
+    test("empty data produces no-op SET on conflict column", () => {
+      const { sql, params } = buildUpsertQuery("users", "email", "id", { id: "u1", email: "a@b.com" }, {});
+      expect(sql).toContain('ON CONFLICT ("email") DO UPDATE SET "email" = EXCLUDED."email"');
+      expect(params).toEqual(["u1", "a@b.com"]);
+    });
+    test("maps conflict column via mapField when primaryKey differs", () => {
+      const { sql } = buildUpsertQuery("users", "id", "user_id", { user_id: "u1", name: "A" }, {});
+      expect(sql).toContain('ON CONFLICT ("user_id")');
+    });
+    test("handles ops in upsert SET clause", () => {
+      const data = flattenOps2([new IncOp2("views", 1)]);
+      const { sql, params } = buildUpsertQuery("posts", "slug", "id", { id: "p1", slug: "hello", views: 0 }, data);
+      expect(sql).toContain('"views" = "views" + $4');
+      expect(params).toEqual(["p1", "hello", 0, 1]);
+    });
+  });
+  describe("extractUpsertConflictColumn", () => {
+    test("extracts field from single eq filter", () => {
+      const filter = FilterGroup2.create().eq("email", "a@b.com");
+      expect(extractUpsertConflictColumn(filter, "users")).toBe("email");
+    });
+    test("throws upsert-filter-incompatible on empty filter", () => {
+      const filter = FilterGroup2.create();
+      expect(() => extractUpsertConflictColumn(filter, "users")).toThrow(OrmValidationError2);
+      try {
+        extractUpsertConflictColumn(filter, "users");
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.schema).toBe("users");
+        expect(err.operation).toBe("upsertOne");
+        expect(err.failures[0].cause).toContain("empty filter");
+      }
+    });
+    test("throws upsert-filter-incompatible on multiple filters", () => {
+      const filter = FilterGroup2.create().eq("a", 1).eq("b", 2);
+      expect(() => extractUpsertConflictColumn(filter, "users")).toThrow(OrmValidationError2);
+      try {
+        extractUpsertConflictColumn(filter, "users");
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.failures[0].cause).toContain("2 filter clauses");
+      }
+    });
+    test("throws upsert-filter-incompatible on non-eq filter", () => {
+      const filter = FilterGroup2.create().gt("age", 10);
+      expect(() => extractUpsertConflictColumn(filter, "users")).toThrow(OrmValidationError2);
+      try {
+        extractUpsertConflictColumn(filter, "users");
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.failures[0].cause).toContain("non-eq filter");
+      }
+    });
+    test("throws with clear message naming received filter shape", () => {
+      const filter = FilterGroup2.create().in("status", ["a", "b"]);
+      try {
+        extractUpsertConflictColumn(filter, "test");
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.failures[0].cause).toContain("single eq filter");
+        expect(err.failures[0].cause).toContain("UNIQUE-indexed column");
+      }
+    });
+  });
+  describe("buildAggregateQuery", () => {
+    test("bare count produces SELECT COUNT(*) AS alias", () => {
+      const { sql, params } = buildAggregateQuery(
+        { aggregates: [{ fn: "count", alias: "total" }], groupBy: [] },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(*) AS "total" FROM "orders"');
+      expect(params).toEqual([]);
+    });
+    test("multi-aggregator produces all functions", () => {
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [
+            { fn: "count", alias: "cnt" },
+            { fn: "sum", field: "amount", alias: "revenue" },
+            { fn: "avg", field: "amount", alias: "avgAmt" },
+            { fn: "min", field: "amount", alias: "lo" },
+            { fn: "max", field: "amount", alias: "hi" }
+          ],
+          groupBy: []
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "cnt", SUM("amount") AS "revenue", AVG("amount") AS "avgAmt", MIN("amount") AS "lo", MAX("amount") AS "hi" FROM "orders"'
+      );
+      expect(params).toEqual([]);
+    });
+    test("countDistinct produces COUNT(DISTINCT col)", () => {
+      const { sql } = buildAggregateQuery(
+        { aggregates: [{ fn: "countDistinct", field: "category", alias: "unique" }], groupBy: [] },
+        "items",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(DISTINCT "category") AS "unique" FROM "items"');
+    });
+    test("single-column groupBy produces GROUP BY clause", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region"]
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(*) AS "cnt", "region" AS "region" FROM "orders" GROUP BY "region"');
+    });
+    test("multi-column groupBy produces all GROUP BY columns", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region", "product"]
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "cnt", "region" AS "region", "product" AS "product" FROM "orders" GROUP BY "region", "product"'
+      );
+    });
+    test("where-only produces WHERE clause with params", () => {
+      const where = FilterGroup2.create().eq("status", "active");
+      const { sql, params } = buildAggregateQuery(
+        { aggregates: [{ fn: "count", alias: "total" }], groupBy: [], where },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(*) AS "total" FROM "orders" WHERE "status" = $1');
+      expect(params).toEqual(["active"]);
+    });
+    test("having-only filters on aggregate alias via repeated expression", () => {
+      const having = FilterGroup2.create().gt("total", 10);
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "total" }],
+          groupBy: ["region"],
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "total", "region" AS "region" FROM "orders" GROUP BY "region" HAVING COUNT(*) > $1'
+      );
+      expect(params).toEqual([10]);
+    });
+    test("where + having both produce correct param ordering", () => {
+      const where = FilterGroup2.create().eq("status", "active");
+      const having = FilterGroup2.create().gte("revenue", 1e3);
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "sum", field: "amount", alias: "revenue" }],
+          groupBy: ["region"],
+          where,
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT SUM("amount") AS "revenue", "region" AS "region" FROM "orders" WHERE "status" = $1 GROUP BY "region" HAVING SUM("amount") >= $2'
+      );
+      expect(params).toEqual(["active", 1e3]);
+    });
+    test("having on groupBy field uses column name directly", () => {
+      const having = FilterGroup2.create().eq("region", "US");
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region"],
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "cnt", "region" AS "region" FROM "orders" GROUP BY "region" HAVING "region" = $1'
+      );
+      expect(params).toEqual(["US"]);
+    });
+    test("field-name mapping: id maps to primaryKey when primaryKey differs", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "countDistinct", field: "id", alias: "uniqueIds" }],
+          groupBy: []
+        },
+        "users",
+        "user_id"
+      );
+      expect(sql).toBe('SELECT COUNT(DISTINCT "user_id") AS "uniqueIds" FROM "users"');
+    });
+    test("groupBy with id field maps to primaryKey", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["id"]
+        },
+        "users",
+        "user_id"
+      );
+      expect(sql).toContain('GROUP BY "user_id"');
+      expect(sql).toContain('"user_id" AS "id"');
+    });
+    test("complex having with AND/OR groups", () => {
+      const having = FilterGroup2.create().and([
+        (q) => q.gt("cnt", 5),
+        (q) => q.or([(g) => g.eq("region", "US"), (g) => g.eq("region", "EU")])
+      ]);
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region"],
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toContain('HAVING (COUNT(*) > $1 AND ("region" = $2 OR "region" = $3))');
+      expect(params).toEqual([5, "US", "EU"]);
+    });
+  });
+}
+
+// src/orm/adapters/postgresql/index.ts
+var postgresqlConnectionPipe = () => v.object({
+  host: v.string(),
+  port: v.number(),
+  username: v.string(),
+  password: v.string(),
+  database: v.string(),
+  ssl: v.defaults(v.boolean(), false)
+});
+var TRACKER_TABLE = "equipped_migrations";
+var ADVISORY_LOCK_KEY = 3735928559;
+var DEFAULT_CURSOR_BATCH_SIZE = 1e3;
+var FIELD_TYPE_TO_PG = {
+  string: "text",
+  number: "double precision",
+  boolean: "boolean",
+  date: "timestamptz",
+  null: "text",
+  object: "jsonb",
+  array: "jsonb"
+};
+var PG_TO_FIELD_TYPE = {
+  text: "string",
+  "character varying": "string",
+  varchar: "string",
+  char: "string",
+  character: "string",
+  "double precision": "number",
+  real: "number",
+  integer: "number",
+  smallint: "number",
+  numeric: "number",
+  decimal: "number",
+  boolean: "boolean",
+  "timestamp with time zone": "date",
+  "timestamp without time zone": "date",
+  timestamptz: "date",
+  timestamp: "date",
+  date: "date",
+  jsonb: "object",
+  json: "object"
+};
+var PostgresAdapter = class extends configurable(postgresqlConnectionPipe, OrmAdapter) {
+  schemaConfigPipe = v.object({
+    schema: v.optional(v.string()),
+    table: v.string()
+  });
+  supportedFieldTypes = ["string", "number", "boolean", "null", "object", "array", "date"];
+  queryableOps = [
+    "eq",
+    "ne",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "in",
+    "notIn",
+    "like",
+    "exists",
+    "notExists",
+    "contains",
+    "notContains"
+  ];
+  updateOps = ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+  aggregateOps = ["count", "countDistinct", "sum", "avg", "min", "max"];
+  pool;
+  #sessionStore = new AsyncLocalStorage();
+  constructor(config) {
+    super(config);
+    this.pool = new Pool({
+      host: config.host,
+      port: config.port,
+      user: config.username,
+      password: config.password,
+      database: config.database,
+      ssl: config.ssl ? { rejectUnauthorized: false } : false
+    });
+  }
+  #getClient() {
+    return this.#sessionStore.getStore() ?? this.pool;
+  }
+  #resolveTableName(config) {
+    return config.schema && config.schema !== "public" ? `${config.schema}.${config.table}` : config.table;
+  }
+  async connect() {
+  }
+  async disconnect() {
+    try {
+      await this.pool.end();
+    } catch (error) {
+      throw new EquippedError("Failed to disconnect PostgreSQL pool", { adapter: "postgresql" }, error);
+    }
+  }
+  async findByPk(schema, config, pk) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const pkName = schema.pkField.name;
+      const result = await this.#getClient().query(`SELECT * FROM "${tableName}" WHERE "${pkName}" = $1`, [pk]);
+      return result.rows[0] ?? null;
+    } catch (error) {
+      throw new EquippedError("PostgreSQL findByPk failed", { adapter: "postgresql", operation: "findByPk", table: c.table }, error);
+    }
+  }
+  async createMany(_schema, config, data) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const client = this.#getClient();
+      const results = [];
+      for (const doc of data) {
+        const { sql, params } = buildCreateQuery(tableName, doc);
+        const result = await client.query(sql, params);
+        results.push(result.rows[0]);
+      }
+      return results;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL createMany failed",
+        { adapter: "postgresql", operation: "createMany", table: c.table },
+        error
+      );
+    }
+  }
+  async updateByPk(schema, config, pk, ops) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const pkName = schema.pkField.name;
+      const data = flattenOps(ops);
+      if (Object.keys(data).length === 0) {
+        const result2 = await this.#getClient().query(`SELECT * FROM "${tableName}" WHERE "${pkName}" = $1`, [pk]);
+        return result2.rows[0] ?? null;
+      }
+      const { sql, params } = buildPkUpdateQuery(tableName, pkName, pk, data);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows[0] ?? null;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL updateByPk failed",
+        { adapter: "postgresql", operation: "updateByPk", table: c.table },
+        error
+      );
+    }
+  }
+  async deleteByPk(schema, config, pk) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const pkName = schema.pkField.name;
+      const result = await this.#getClient().query(`DELETE FROM "${tableName}" WHERE "${pkName}" = $1 RETURNING *`, [pk]);
+      return result.rows[0] ?? null;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL deleteByPk failed",
+        { adapter: "postgresql", operation: "deleteByPk", table: c.table },
+        error
+      );
+    }
+  }
+  async raw(_schema, config, command, params = []) {
+    const c = config;
+    try {
+      const result = await this.#getClient().query(command, params);
+      return result;
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL raw failed", { adapter: "postgresql", operation: "raw", table: c.table }, error);
+    }
+  }
+  async findMany(schema, config, filter, options) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildSelectQuery(filter, options, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows;
+    } catch (error) {
+      throw new EquippedError("PostgreSQL findMany failed", { adapter: "postgresql", operation: "findMany", table: c.table }, error);
+    }
+  }
+  async count(schema, config, filter) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildCountQuery(filter, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return Number(result.rows[0]?.count ?? 0);
+    } catch (error) {
+      throw new EquippedError("PostgreSQL count failed", { adapter: "postgresql", operation: "count", table: c.table }, error);
+    }
+  }
+  async *iterateMany(schema, config, filter, options) {
+    const c = config;
+    let client;
+    let releaseClient = false;
+    let cursor;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildSelectQuery(filter, options, tableName, schema.pkField.name);
+      const sessionClient = this.#sessionStore.getStore();
+      if (sessionClient) {
+        client = sessionClient;
+      } else {
+        client = await this.pool.connect();
+        releaseClient = true;
+      }
+      cursor = client.query(new Cursor(sql, params));
+      const batchSize = options?.batchSize ?? DEFAULT_CURSOR_BATCH_SIZE;
+      while (true) {
+        const rows = await cursor.read(batchSize);
+        if (rows.length === 0) break;
+        for (const row of rows) yield row;
+      }
+    } catch (error) {
+      throw new EquippedError("PostgreSQL iterateMany failed", { adapter: "postgresql", operation: "iterateMany", table: c.table }, error);
+    } finally {
+      try {
+        await cursor?.close();
+      } finally {
+        if (releaseClient) client?.release();
+      }
+    }
+  }
+  async updateMany(schema, config, filter, data) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildUpdateQuery(filter, tableName, schema.pkField.name, data);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL updateMany failed",
+        { adapter: "postgresql", operation: "updateMany", table: c.table },
+        error
+      );
+    }
+  }
+  async deleteMany(schema, config, filter) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildDeleteQuery(filter, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL deleteMany failed",
+        { adapter: "postgresql", operation: "deleteMany", table: c.table },
+        error
+      );
+    }
+  }
+  async upsertOne(schema, config, filter, create, ops) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const conflictColumn = extractUpsertConflictColumn(filter, schema.name);
+      const data = ops.length > 0 ? flattenOps(ops) : {};
+      const { sql, params } = buildUpsertQuery(tableName, conflictColumn, schema.pkField.name, create, data);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows[0];
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL upsertOne failed", { adapter: "postgresql", operation: "upsertOne", table: c.table }, error);
+    }
+  }
+  async aggregate(schema, config, spec) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildAggregateQuery(spec, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows.map((row) => {
+        const mapped = {};
+        for (const agg of spec.aggregates) {
+          const val = row[agg.alias];
+          if (agg.fn === "min" || agg.fn === "max") {
+            mapped[agg.alias] = val;
+          } else {
+            mapped[agg.alias] = typeof val === "string" ? Number(val) : Number(val ?? 0);
+          }
+        }
+        for (const field of spec.groupBy) {
+          mapped[field] = row[field];
+        }
+        return mapped;
+      });
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL aggregate failed", { adapter: "postgresql", operation: "aggregate", table: c.table }, error);
+    }
+  }
+  async loadMigrations() {
+    const client = this.#getClient();
+    await client.query(`
+			CREATE TABLE IF NOT EXISTS "${TRACKER_TABLE}" (
+				id text PRIMARY KEY,
+				applied_at bigint NOT NULL
+			)
+		`);
+    const result = await client.query(`SELECT id, applied_at FROM "${TRACKER_TABLE}"`);
+    return result.rows.map((row) => ({ id: row.id, appliedAt: Number(row.applied_at) }));
+  }
+  async recordMigration(id, appliedAt) {
+    const client = this.#getClient();
+    await client.query(`INSERT INTO "${TRACKER_TABLE}" (id, applied_at) VALUES ($1, $2)`, [id, appliedAt]);
+  }
+  async acquireMigrationLock(fn) {
+    const client = this.#getClient();
+    await client.query(`SELECT pg_advisory_lock($1)`, [ADVISORY_LOCK_KEY]);
+    try {
+      return await fn();
+    } finally {
+      await client.query(`SELECT pg_advisory_unlock($1)`, [ADVISORY_LOCK_KEY]);
+    }
+  }
+  async applyCreateTable(change) {
+    const pkType = FIELD_TYPE_TO_PG[change.pk.type] ?? "text";
+    const cols = [`"${change.pk.name}" ${pkType} PRIMARY KEY`];
+    for (const f of change.fields) {
+      cols.push(this.#renderColumnDef(f));
+    }
+    await this.#getClient().query(`CREATE TABLE "${change.name}" (${cols.join(", ")})`);
+  }
+  async applyDropTable(change) {
+    await this.#getClient().query(`DROP TABLE "${change.name}"`);
+  }
+  async applyAddField(change) {
+    const colDef = this.#renderColumnDef(change.field);
+    await this.#getClient().query(`ALTER TABLE "${change.table}" ADD COLUMN ${colDef}`);
+  }
+  async applyDropField(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.table}" DROP COLUMN "${change.name}"`);
+  }
+  async applyModifyField(change) {
+    const client = this.#getClient();
+    const table = `"${change.table}"`;
+    const col = `"${change.name}"`;
+    const newType = FIELD_TYPE_TO_PG[change.to.type] ?? "text";
+    await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} TYPE ${newType} USING ${col}::${newType}`);
+    if (change.to.nullable) {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} DROP NOT NULL`);
+    } else {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} SET NOT NULL`);
+    }
+    if (change.to.default !== void 0) {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} SET DEFAULT ${this.#renderDefault(change.to.default)}`);
+    } else {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} DROP DEFAULT`);
+    }
+    if (change.to.name !== change.name) {
+      await client.query(`ALTER TABLE ${table} RENAME COLUMN ${col} TO "${change.to.name}"`);
+    }
+  }
+  async applyRenameTable(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.from}" RENAME TO "${change.to}"`);
+  }
+  async applyRenameField(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.table}" RENAME COLUMN "${change.from}" TO "${change.to}"`);
+  }
+  async applyAddIndex(change) {
+    const name = change.name ?? this.#deriveIndexName(change.table, change.on, change.unique);
+    const unique = change.unique ? "UNIQUE " : "";
+    const cols = change.on.map((c) => `"${c}"`).join(", ");
+    await this.#getClient().query(`CREATE ${unique}INDEX "${name}" ON "${change.table}" (${cols})`);
+  }
+  async applyDropIndex(change) {
+    await this.#getClient().query(`DROP INDEX "${change.name}"`);
+  }
+  async applyAddForeignKey(change) {
+    const name = change.name ?? `fk_${change.table}_${change.on}`;
+    let sql = `ALTER TABLE "${change.table}" ADD CONSTRAINT "${name}" FOREIGN KEY ("${change.on}") REFERENCES "${change.references.table}" ("${change.references.column}")`;
+    if (change.onDelete) sql += ` ON DELETE ${this.#renderFkAction(change.onDelete)}`;
+    if (change.onUpdate) sql += ` ON UPDATE ${this.#renderFkAction(change.onUpdate)}`;
+    await this.#getClient().query(sql);
+  }
+  async applyDropForeignKey(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.table}" DROP CONSTRAINT "${change.name}"`);
+  }
+  async introspect() {
+    const { OrmIntrospectionError } = await import("../../../introspection-VOIU3XE6.js");
+    const client = this.#getClient();
+    const tablesResult = await client.query(`
+			SELECT table_name FROM information_schema.tables
+			WHERE table_schema = 'public' AND table_type = 'BASE TABLE' AND table_name != $1
+		`, [TRACKER_TABLE]);
+    const schemas = [];
+    for (const tableRow of tablesResult.rows) {
+      const tableName = tableRow.table_name;
+      const colsResult = await client.query(`
+				SELECT column_name, data_type, is_nullable, column_default
+				FROM information_schema.columns
+				WHERE table_schema = 'public' AND table_name = $1
+				ORDER BY ordinal_position
+			`, [tableName]);
+      const pkResult = await client.query(`
+				SELECT kcu.column_name
+				FROM information_schema.table_constraints tc
+				JOIN information_schema.key_column_usage kcu
+					ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+				WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'PRIMARY KEY'
+			`, [tableName]);
+      const pkColName = pkResult.rows[0]?.column_name;
+      const uniqueResult = await client.query(`
+				SELECT kcu.column_name
+				FROM information_schema.table_constraints tc
+				JOIN information_schema.key_column_usage kcu
+					ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+				WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
+			`, [tableName]);
+      const uniqueCols = new Set(uniqueResult.rows.map((r) => r.column_name));
+      let pk;
+      const fields = [];
+      for (const col of colsResult.rows) {
+        const pgType = col.data_type.toLowerCase();
+        const fieldType = PG_TO_FIELD_TYPE[pgType];
+        if (!fieldType) {
+          throw new OrmIntrospectionError({ adapter: "postgresql", table: tableName, cause: `Unsupported column type '${pgType}' on column '${col.column_name}'` });
+        }
+        if (col.column_name === pkColName) {
+          pk = { name: col.column_name, type: fieldType };
+          continue;
+        }
+        const nullable = col.is_nullable === "YES";
+        const raw = col.column_default;
+        const def = this.#parseDefault(raw);
+        fields.push({
+          name: col.column_name,
+          type: fieldType,
+          nullable,
+          ...def !== void 0 ? { default: def } : {},
+          ...uniqueCols.has(col.column_name) ? { unique: true } : {}
+        });
+      }
+      const idxResult = await client.query(`
+				SELECT indexname, indexdef
+				FROM pg_indexes
+				WHERE schemaname = 'public' AND tablename = $1
+			`, [tableName]);
+      const indexes = [];
+      for (const idx of idxResult.rows) {
+        const idxName = idx.indexname;
+        const idxDef = idx.indexdef;
+        if (idxDef.includes("PRIMARY KEY") || idxName.endsWith("_pkey")) continue;
+        const unique = idxDef.toUpperCase().includes("UNIQUE");
+        const colMatch = idxDef.match(/\(([^)]+)\)/);
+        const cols = colMatch ? colMatch[1].split(",").map((c) => c.trim().replace(/"/g, "")) : [];
+        indexes.push({ name: idxName, on: cols, unique });
+      }
+      const fkResult = await client.query(`
+				SELECT
+					tc.constraint_name,
+					kcu.column_name,
+					ccu.table_name AS foreign_table_name,
+					ccu.column_name AS foreign_column_name,
+					rc.delete_rule,
+					rc.update_rule
+				FROM information_schema.table_constraints tc
+				JOIN information_schema.key_column_usage kcu
+					ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+				JOIN information_schema.constraint_column_usage ccu
+					ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
+				JOIN information_schema.referential_constraints rc
+					ON tc.constraint_name = rc.constraint_name AND tc.table_schema = rc.constraint_schema
+				WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'FOREIGN KEY'
+			`, [tableName]);
+      const foreignKeys = [];
+      for (const fk of fkResult.rows) {
+        foreignKeys.push({
+          name: fk.constraint_name,
+          on: fk.column_name,
+          references: { table: fk.foreign_table_name, column: fk.foreign_column_name },
+          ...fk.delete_rule && fk.delete_rule !== "NO ACTION" ? { onDelete: this.#parseFkAction(fk.delete_rule) } : {},
+          ...fk.update_rule && fk.update_rule !== "NO ACTION" ? { onUpdate: this.#parseFkAction(fk.update_rule) } : {}
+        });
+      }
+      schemas.push({ name: tableName, pk, fields, indexes, foreignKeys });
+    }
+    return schemas;
+  }
+  #renderColumnDef(f) {
+    const pgType = FIELD_TYPE_TO_PG[f.type] ?? "text";
+    let def = `"${f.name}" ${pgType}`;
+    if (!f.nullable) def += " NOT NULL";
+    if (f.default !== void 0) def += ` DEFAULT ${this.#renderDefault(f.default)}`;
+    if (f.unique) def += " UNIQUE";
+    return def;
+  }
+  #renderDefault(val) {
+    if (val === null) return "NULL";
+    if (typeof val === "string") return `'${val.replace(/'/g, "''")}'`;
+    if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+    return String(val);
+  }
+  #deriveIndexName(table, cols, unique) {
+    const base = `idx_${table}_${cols.join("_")}`;
+    return unique ? `${base}_unique` : base;
+  }
+  #renderFkAction(action) {
+    const map = { cascade: "CASCADE", restrict: "RESTRICT", setnull: "SET NULL", noaction: "NO ACTION" };
+    return map[action.toLowerCase()] ?? "NO ACTION";
+  }
+  #parseFkAction(rule) {
+    const map = { CASCADE: "cascade", RESTRICT: "restrict", "SET NULL": "setNull" };
+    return map[rule.toUpperCase()] ?? "noAction";
+  }
+  #parseDefault(raw) {
+    if (raw === null || raw === void 0) return void 0;
+    if (raw === "NULL" || raw === "NULL::text") return null;
+    if (raw === "true" || raw === "TRUE") return true;
+    if (raw === "false" || raw === "FALSE") return false;
+    const numMatch = raw.match(/^(-?\d+(?:\.\d+)?)$/);
+    if (numMatch) return Number(numMatch[1]);
+    const strMatch = raw.match(/^'(.*)'(?:::.*)?$/);
+    if (strMatch) return strMatch[1].replace(/''/g, "'");
+    return void 0;
+  }
+  async session(fn) {
+    if (this.#sessionStore.getStore()) return fn();
+    let client;
+    try {
+      client = await this.pool.connect();
+      await client.query("BEGIN");
+      const result = await this.#sessionStore.run(client, fn);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      if (client) {
+        try {
+          await client.query("ROLLBACK");
+        } catch {
+        }
+      }
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL session failed", { adapter: "postgresql", operation: "session" }, error);
+    } finally {
+      client?.release();
+    }
+  }
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf, vi, beforeEach, afterEach } = void 0;
+  const testConnectionConfig = {
+    host: "localhost",
+    port: 5432,
+    username: "test",
+    password: "test",
+    database: "testdb",
+    ssl: false
+  };
+  describe("PostgresAdapter: class-via-configurable shape", () => {
+    let onSpy;
+    beforeEach(async () => {
+      const { Instance } = await null;
+      onSpy = vi.spyOn(Instance, "on").mockImplementation(() => {
+      });
+    });
+    afterEach(() => {
+      onSpy.mockRestore();
+    });
+    test("PostgresAdapter.create returns instance with correct capability declarations", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.supportedFieldTypes).toEqual(["string", "number", "boolean", "null", "object", "array", "date"]);
+      expect(adapter.queryableOps).toEqual([
+        "eq",
+        "ne",
+        "gt",
+        "gte",
+        "lt",
+        "lte",
+        "in",
+        "notIn",
+        "like",
+        "exists",
+        "notExists",
+        "contains",
+        "notContains"
+      ]);
+      expect(adapter.updateOps).toEqual(["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"]);
+    });
+    test("PostgresAdapter.create validates connection config", () => {
+      expect(() => PostgresAdapter.create({ host: 123, port: "bad" })).toThrow();
+    });
+    test("pool is exposed as a readonly instance field", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.pool).toBeInstanceOf(Pool);
+    });
+    test("schemaConfigPipe is declared as readonly with table-name shape", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.schemaConfigPipe).toBeDefined();
+    });
+    test("auto-wires Instance hooks for connect and disconnect", () => {
+      PostgresAdapter.create(testConnectionConfig);
+      expect(onSpy).toHaveBeenCalledWith("start", expect.any(Function), expect.objectContaining({ class: PostgresAdapter }));
+      expect(onSpy).toHaveBeenCalledWith("close", expect.any(Function), expect.objectContaining({ class: PostgresAdapter }));
+    });
+    test("adapter.use returns OrmUse-shaped object", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("test").pk("id", v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const use = adapter.use(schema, { table: "test" });
+      expect(use.findMany).toBeTypeOf("function");
+      expect(use.iterateMany).toBeTypeOf("function");
+      expect(use.findOne).toBeTypeOf("function");
+      expect(use.count).toBeTypeOf("function");
+      expect(use.createOne).toBeTypeOf("function");
+      expect(use.createMany).toBeTypeOf("function");
+      expect(use.updateMany).toBeTypeOf("function");
+      expect(use.updateOne).toBeTypeOf("function");
+      expect(use.upsertOne).toBeTypeOf("function");
+      expect(use.deleteOne).toBeTypeOf("function");
+      expect(use.deleteMany).toBeTypeOf("function");
+      expect(use.raw).toBeTypeOf("function");
+    });
+    test("type-level: capability declarations use as const", () => {
+      const _adapter = PostgresAdapter.create(testConnectionConfig);
+      expectTypeOf().toEqualTypeOf();
+      expectTypeOf().toEqualTypeOf();
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("type-level: Repo.from with PostgresAdapter enables all builder methods", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v.string(), () => "x").build();
+      const _one = repo.on(_TestSchema).one();
+      const _all = repo.on(_TestSchema).all();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_one.create).toBeFunction();
+      expectTypeOf(_one.find).toBeFunction();
+      expectTypeOf(_one.update).toBeFunction();
+      expectTypeOf(_one.delete).toBeFunction();
+      expectTypeOf(_one.upsert).toBeFunction();
+      expectTypeOf(_all.create).toBeFunction();
+      expectTypeOf(_all.find).toBeFunction();
+      expectTypeOf(_all.count).toBeFunction();
+      expectTypeOf(_all.update).toBeFunction();
+      expectTypeOf(_all.delete).toBeFunction();
+      expectTypeOf(_ref.raw).toBeFunction();
+      expectTypeOf(repo.session).toBeFunction();
+    });
+    test("type-level: raw arg-tuple infers (command: string, params?: unknown[]) from PostgresAdapter", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.raw).parameters.toEqualTypeOf();
+    });
+    test("type-level: per-call <T> override narrows PostgresAdapter raw return type", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.raw).returns.toEqualTypeOf();
+    });
+    test("count forwards COUNT query to pool.query and returns a number", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_count").pk("id", v.string(), () => "x").field("name", v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedSql;
+      let capturedParams;
+      adapter.pool.query = async (sql, params) => {
+        capturedSql = sql;
+        capturedParams = params;
+        return { rows: [{ count: "4" }] };
+      };
+      const result = await adapter.count(schema, { table: "users" }, FilterGroup2.create().eq("name", "Alice"));
+      expect(capturedSql).toBe('SELECT COUNT(*) as count FROM "users" WHERE "name" = $1');
+      expect(capturedParams).toEqual(["Alice"]);
+      expect(result).toBe(4);
+    });
+    test("raw forwards (command, params) to pool.query at runtime", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_raw").pk("id", v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedCommand;
+      let capturedParams;
+      const mockResult = { rows: [{ id: "1" }], rowCount: 1 };
+      adapter.pool.query = async (cmd, params) => {
+        capturedCommand = cmd;
+        capturedParams = params;
+        return mockResult;
+      };
+      const result = await adapter.use(schema, { table: "users" }).raw("SELECT * FROM users WHERE id = $1", ["abc"]);
+      expect(capturedCommand).toBe("SELECT * FROM users WHERE id = $1");
+      expect(capturedParams).toEqual(["abc"]);
+      expect(result).toBe(mockResult);
+    });
+    test("raw defaults params to [] when omitted", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_raw2").pk("id", v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedParams;
+      adapter.pool.query = async (_cmd, params) => {
+        capturedParams = params;
+        return { rows: [] };
+      };
+      await adapter.use(schema, { table: "users" }).raw("SELECT 1");
+      expect(capturedParams).toEqual([]);
+    });
+    test("iterateMany opens a dedicated cursor client, reads in batchSize chunks, and releases on completion", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const { OrderBy } = await null;
+      const schema = Schema.from("pg_iter").pk("id", v.string(), () => "x").field("age", v.number()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedCursor;
+      const release = vi.fn();
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u3", age: 40 }]).mockResolvedValueOnce([{ id: "u1", age: 30 }]).mockResolvedValueOnce([]),
+        close: vi.fn().mockResolvedValue(void 0)
+      };
+      const client = {
+        query: vi.fn((query) => {
+          capturedCursor = query;
+          return cursor;
+        }),
+        release
+      };
+      adapter.pool.connect = vi.fn(async () => client);
+      const rows = [];
+      for await (const row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create().gt("age", 19), {
+        orderBy: [new OrderBy("age", "desc")],
+        offset: 1,
+        limit: 2,
+        batchSize: 1
+      })) {
+        rows.push(row);
+      }
+      expect(adapter.pool.connect).toHaveBeenCalledTimes(1);
+      expect(capturedCursor).toBeInstanceOf(Cursor);
+      const capturedCursorConfig = capturedCursor;
+      expect(capturedCursorConfig.text).toBe('SELECT * FROM "people" WHERE "age" > $1 ORDER BY "age" DESC LIMIT $2 OFFSET $3');
+      expect(capturedCursorConfig.values).toEqual(["19", "2", "1"]);
+      expect(cursor.read).toHaveBeenNthCalledWith(1, 1);
+      expect(cursor.read).toHaveBeenNthCalledWith(2, 1);
+      expect(cursor.read).toHaveBeenNthCalledWith(3, 1);
+      expect(cursor.close).toHaveBeenCalledTimes(1);
+      expect(release).toHaveBeenCalledTimes(1);
+      expect(rows).toEqual([{ id: "u3", age: 40 }, { id: "u1", age: 30 }]);
+    });
+    test("iterateMany closes cursor and releases dedicated client on early break", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_iter_break").pk("id", v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const release = vi.fn();
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u1" }, { id: "u2" }]),
+        close: vi.fn().mockResolvedValue(void 0)
+      };
+      adapter.pool.connect = vi.fn(async () => ({
+        query: vi.fn(() => cursor),
+        release
+      }));
+      const rows = [];
+      for await (const row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create())) {
+        rows.push(row);
+        break;
+      }
+      expect(rows).toEqual([{ id: "u1" }]);
+      expect(cursor.close).toHaveBeenCalledTimes(1);
+      expect(release).toHaveBeenCalledTimes(1);
+    });
+    test("iterateMany closes cursor and releases dedicated client when the consumer throws", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_iter_throw").pk("id", v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const release = vi.fn();
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u1" }]),
+        close: vi.fn().mockResolvedValue(void 0)
+      };
+      adapter.pool.connect = vi.fn(async () => ({
+        query: vi.fn(() => cursor),
+        release
+      }));
+      const consumerError = new Error("consumer failed");
+      await expect(async () => {
+        for await (const _row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create())) {
+          throw consumerError;
+        }
+      }).rejects.toThrow(consumerError);
+      expect(cursor.close).toHaveBeenCalledTimes(1);
+      expect(release).toHaveBeenCalledTimes(1);
+    });
+    test("iterateMany inside a session uses the active client and leaves release ownership to session", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_iter_session").pk("id", v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const events = [];
+      const release = vi.fn(() => events.push("release"));
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u1" }]).mockResolvedValueOnce([]),
+        close: vi.fn(async () => events.push("cursor.close"))
+      };
+      const client = {
+        query: vi.fn((query) => {
+          if (typeof query === "string") {
+            events.push(query);
+            return { rows: [] };
+          }
+          events.push("cursor.open");
+          return cursor;
+        }),
+        release
+      };
+      adapter.pool.connect = vi.fn(async () => client);
+      const rows = [];
+      await adapter.session(async () => {
+        for await (const row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create(), { batchSize: 1 })) {
+          rows.push(row);
+        }
+        events.push("session.body.done");
+      });
+      expect(adapter.pool.connect).toHaveBeenCalledTimes(1);
+      expect(rows).toEqual([{ id: "u1" }]);
+      expect(events).toEqual(["BEGIN", "cursor.open", "cursor.close", "session.body.done", "COMMIT", "release"]);
+      expect(release).toHaveBeenCalledTimes(1);
+    });
+    test("session method is exposed on the adapter", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.session).toBeDefined();
+      expect(adapter.session).toBeTypeOf("function");
+    });
+    test("declares aggregateOps with all six canonical ops", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.aggregateOps).toEqual(["count", "countDistinct", "sum", "avg", "min", "max"]);
+    });
+    test("type-level: aggregateOps is a readonly tuple of all six ops", () => {
+      const _adapter = PostgresAdapter.create(testConnectionConfig);
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("aggregate method forwards spec to pool.query and returns mapped rows", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg").pk("id", v.string(), () => "x").field("amount", v.number()).field("region", v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedSql;
+      let capturedParams;
+      adapter.pool.query = async (sql, params) => {
+        capturedSql = sql;
+        capturedParams = params;
+        return { rows: [{ total: "5" }] };
+      };
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(capturedSql).toBe('SELECT COUNT(*) AS "total" FROM "orders"');
+      expect(capturedParams).toEqual([]);
+      expect(result).toEqual([{ total: 5 }]);
+    });
+    test("aggregate converts PG bigint/numeric strings to numbers for count/sum/avg", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg_types").pk("id", v.string(), () => "x").field("amount", v.number()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      adapter.pool.query = async () => ({
+        rows: [{ cnt: "10", revenue: "250.50", avgAmt: "25.05" }]
+      });
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [
+          { fn: "count", alias: "cnt" },
+          { fn: "sum", field: "amount", alias: "revenue" },
+          { fn: "avg", field: "amount", alias: "avgAmt" }
+        ],
+        groupBy: []
+      });
+      expect(result[0].cnt).toBe(10);
+      expect(result[0].revenue).toBe(250.5);
+      expect(result[0].avgAmt).toBe(25.05);
+    });
+    test("aggregate preserves original type for min/max", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg_minmax").pk("id", v.string(), () => "x").field("name", v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      adapter.pool.query = async () => ({
+        rows: [{ lowest: "Alice", highest: "Zara" }]
+      });
+      const result = await adapter.aggregate(schema, { table: "users" }, {
+        aggregates: [
+          { fn: "min", field: "name", alias: "lowest" },
+          { fn: "max", field: "name", alias: "highest" }
+        ],
+        groupBy: []
+      });
+      expect(result[0].lowest).toBe("Alice");
+      expect(result[0].highest).toBe("Zara");
+    });
+    test("aggregate includes groupBy fields in result rows", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg_group").pk("id", v.string(), () => "x").field("region", v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      adapter.pool.query = async () => ({
+        rows: [
+          { cnt: "3", region: "US" },
+          { cnt: "2", region: "EU" }
+        ]
+      });
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [{ fn: "count", alias: "cnt" }],
+        groupBy: ["region"]
+      });
+      expect(result).toEqual([
+        { cnt: 3, region: "US" },
+        { cnt: 2, region: "EU" }
+      ]);
+    });
+    test("type-level: Repo.from with PostgresAdapter enables aggregate method", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.aggregate).toBeFunction();
+    });
+  });
+  describe("PostgresAdapter: migration methods", () => {
+    let onSpy;
+    let adapter;
+    let queries;
+    beforeEach(async () => {
+      const { Instance } = await null;
+      onSpy = vi.spyOn(Instance, "on").mockImplementation(() => {
+      });
+      adapter = PostgresAdapter.create(testConnectionConfig);
+      queries = [];
+      adapter.pool.query = async (sql, params) => {
+        queries.push({ sql, params });
+        return { rows: [] };
+      };
+    });
+    afterEach(() => {
+      onSpy.mockRestore();
+    });
+    test("loadMigrations creates tracker table then selects rows", async () => {
+      ;
+      adapter.pool.query = async (sql, params) => {
+        queries.push({ sql, params });
+        if (sql.includes("SELECT id")) {
+          return { rows: [{ id: "0001", applied_at: "1700000000000" }] };
+        }
+        return { rows: [] };
+      };
+      const result = await adapter.loadMigrations();
+      expect(queries).toHaveLength(2);
+      expect(queries[0].sql).toContain("CREATE TABLE IF NOT EXISTS");
+      expect(queries[0].sql).toContain("equipped_migrations");
+      expect(queries[1].sql).toContain("SELECT id, applied_at");
+      expect(result).toEqual([{ id: "0001", appliedAt: 17e11 }]);
+    });
+    test("recordMigration inserts into tracker table", async () => {
+      await adapter.recordMigration("0001-init", 17e11);
+      expect(queries).toHaveLength(1);
+      expect(queries[0].sql).toContain("INSERT INTO");
+      expect(queries[0].sql).toContain("equipped_migrations");
+      expect(queries[0].params).toEqual(["0001-init", 17e11]);
+    });
+    test("acquireMigrationLock wraps fn with pg_advisory_lock/unlock", async () => {
+      const result = await adapter.acquireMigrationLock(async () => {
+        queries.push({ sql: "USER_FN" });
+        return 42;
+      });
+      expect(result).toBe(42);
+      expect(queries[0].sql).toContain("pg_advisory_lock");
+      expect(queries[1].sql).toBe("USER_FN");
+      expect(queries[2].sql).toContain("pg_advisory_unlock");
+    });
+    test("acquireMigrationLock unlocks even on error", async () => {
+      await expect(adapter.acquireMigrationLock(async () => {
+        throw new Error("boom");
+      })).rejects.toThrow("boom");
+      expect(queries[0].sql).toContain("pg_advisory_lock");
+      expect(queries[1].sql).toContain("pg_advisory_unlock");
+    });
+    test("applyCreateTable generates correct DDL", async () => {
+      await adapter.applyCreateTable({
+        kind: "createTable",
+        name: "users",
+        pk: { name: "id", type: "string" },
+        fields: [
+          { name: "email", type: "string", unique: true },
+          { name: "age", type: "number", nullable: true },
+          { name: "active", type: "boolean", default: true }
+        ]
+      });
+      expect(queries).toHaveLength(1);
+      const sql = queries[0].sql;
+      expect(sql).toContain('CREATE TABLE "users"');
+      expect(sql).toContain('"id" text PRIMARY KEY');
+      expect(sql).toContain('"email" text NOT NULL UNIQUE');
+      expect(sql).toContain('"age" double precision');
+      expect(sql).not.toContain('"age" double precision NOT NULL');
+      expect(sql).toContain('"active" boolean NOT NULL DEFAULT TRUE');
+    });
+    test("applyDropTable generates DROP TABLE", async () => {
+      await adapter.applyDropTable({ kind: "dropTable", name: "users" });
+      expect(queries[0].sql).toBe('DROP TABLE "users"');
+    });
+    test("applyAddField generates ALTER TABLE ADD COLUMN", async () => {
+      await adapter.applyAddField({
+        kind: "addField",
+        table: "users",
+        field: { name: "bio", type: "string", nullable: true, default: "none" }
+      });
+      expect(queries[0].sql).toContain('ALTER TABLE "users" ADD COLUMN');
+      expect(queries[0].sql).toContain('"bio" text');
+      expect(queries[0].sql).not.toContain("NOT NULL");
+      expect(queries[0].sql).toContain("DEFAULT 'none'");
+    });
+    test("applyDropField generates ALTER TABLE DROP COLUMN", async () => {
+      await adapter.applyDropField({ kind: "dropField", table: "users", name: "bio" });
+      expect(queries[0].sql).toBe('ALTER TABLE "users" DROP COLUMN "bio"');
+    });
+    test("applyModifyField generates ALTER COLUMN statements for type, nullable, default", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "age",
+        to: { name: "age", type: "string", nullable: true, default: null }
+      });
+      expect(queries[0].sql).toContain('ALTER COLUMN "age" TYPE text');
+      expect(queries[1].sql).toContain("DROP NOT NULL");
+      expect(queries[2].sql).toContain("SET DEFAULT NULL");
+    });
+    test("applyModifyField renames column when to.name differs", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "age",
+        to: { name: "years", type: "number" }
+      });
+      const renameSql = queries.find((q) => q.sql.includes("RENAME COLUMN"));
+      expect(renameSql).toBeDefined();
+      expect(renameSql.sql).toContain('RENAME COLUMN "age" TO "years"');
+    });
+    test("applyRenameTable generates ALTER TABLE RENAME", async () => {
+      await adapter.applyRenameTable({ kind: "renameTable", from: "users", to: "accounts" });
+      expect(queries[0].sql).toBe('ALTER TABLE "users" RENAME TO "accounts"');
+    });
+    test("applyRenameField generates ALTER TABLE RENAME COLUMN", async () => {
+      await adapter.applyRenameField({ kind: "renameField", table: "users", from: "name", to: "fullName" });
+      expect(queries[0].sql).toBe('ALTER TABLE "users" RENAME COLUMN "name" TO "fullName"');
+    });
+    test("applyAddIndex generates CREATE INDEX with auto-derived name", async () => {
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"] });
+      expect(queries[0].sql).toBe('CREATE INDEX "idx_users_email" ON "users" ("email")');
+    });
+    test("applyAddIndex generates CREATE UNIQUE INDEX with explicit name", async () => {
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"], unique: true, name: "my_idx" });
+      expect(queries[0].sql).toBe('CREATE UNIQUE INDEX "my_idx" ON "users" ("email")');
+    });
+    test("applyAddIndex auto-derives unique suffix when unique and no name", async () => {
+      await adapter.applyAddIndex({ kind: "addIndex", table: "posts", on: ["author", "title"], unique: true });
+      expect(queries[0].sql).toBe('CREATE UNIQUE INDEX "idx_posts_author_title_unique" ON "posts" ("author", "title")');
+    });
+    test("applyDropIndex generates DROP INDEX", async () => {
+      await adapter.applyDropIndex({ kind: "dropIndex", name: "idx_users_email" });
+      expect(queries[0].sql).toBe('DROP INDEX "idx_users_email"');
+    });
+    test("applyAddForeignKey generates ALTER TABLE ADD CONSTRAINT with auto-derived name", async () => {
+      await adapter.applyAddForeignKey({
+        kind: "addForeignKey",
+        table: "posts",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade",
+        onUpdate: "setNull"
+      });
+      const sql = queries[0].sql;
+      expect(sql).toContain('ALTER TABLE "posts" ADD CONSTRAINT "fk_posts_authorId"');
+      expect(sql).toContain('FOREIGN KEY ("authorId") REFERENCES "users" ("id")');
+      expect(sql).toContain("ON DELETE CASCADE");
+      expect(sql).toContain("ON UPDATE SET NULL");
+    });
+    test("applyAddForeignKey uses explicit name when provided", async () => {
+      await adapter.applyAddForeignKey({
+        kind: "addForeignKey",
+        table: "posts",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        name: "custom_fk"
+      });
+      expect(queries[0].sql).toContain('ADD CONSTRAINT "custom_fk"');
+    });
+    test("applyDropForeignKey generates ALTER TABLE DROP CONSTRAINT", async () => {
+      await adapter.applyDropForeignKey({ kind: "dropForeignKey", table: "posts", name: "fk_posts_authorId" });
+      expect(queries[0].sql).toBe('ALTER TABLE "posts" DROP CONSTRAINT "fk_posts_authorId"');
+    });
+    test("introspect queries information_schema and builds DiscoveredSchema[]", async () => {
+      ;
+      adapter.pool.query = async (sql, params) => {
+        queries.push({ sql, params });
+        if (sql.includes("information_schema.tables")) {
+          return { rows: [{ table_name: "users" }] };
+        }
+        if (sql.includes("information_schema.columns")) {
+          return {
+            rows: [
+              { column_name: "id", data_type: "text", is_nullable: "NO", column_default: null },
+              { column_name: "email", data_type: "character varying", is_nullable: "NO", column_default: null },
+              { column_name: "age", data_type: "integer", is_nullable: "YES", column_default: "25" }
+            ]
+          };
+        }
+        if (sql.includes("PRIMARY KEY")) {
+          return { rows: [{ column_name: "id" }] };
+        }
+        if (sql.includes("constraint_type = 'UNIQUE'")) {
+          return { rows: [{ column_name: "email" }] };
+        }
+        if (sql.includes("pg_indexes")) {
+          return { rows: [{ indexname: "users_email_idx", indexdef: "CREATE UNIQUE INDEX users_email_idx ON public.users USING btree (email)" }] };
+        }
+        if (sql.includes("constraint_type = 'FOREIGN KEY'")) {
+          return { rows: [] };
+        }
+        return { rows: [] };
+      };
+      const schemas = await adapter.introspect();
+      expect(schemas).toHaveLength(1);
+      const s = schemas[0];
+      expect(s.name).toBe("users");
+      expect(s.pk).toEqual({ name: "id", type: "string" });
+      expect(s.fields).toEqual([
+        { name: "email", type: "string", nullable: false, unique: true },
+        { name: "age", type: "number", nullable: true, default: 25 }
+      ]);
+      expect(s.indexes).toEqual([{ name: "users_email_idx", on: ["email"], unique: true }]);
+      expect(s.foreignKeys).toEqual([]);
+    });
+    test("introspect throws OrmIntrospectionError on unsupported PG type", async () => {
+      const { OrmIntrospectionError } = await null;
+      adapter.pool.query = async (sql) => {
+        if (sql.includes("information_schema.tables")) {
+          return { rows: [{ table_name: "files" }] };
+        }
+        if (sql.includes("information_schema.columns")) {
+          return {
+            rows: [
+              { column_name: "id", data_type: "text", is_nullable: "NO", column_default: null },
+              { column_name: "data", data_type: "bytea", is_nullable: "YES", column_default: null }
+            ]
+          };
+        }
+        if (sql.includes("PRIMARY KEY")) {
+          return { rows: [{ column_name: "id" }] };
+        }
+        if (sql.includes("constraint_type = 'UNIQUE'")) {
+          return { rows: [] };
+        }
+        return { rows: [] };
+      };
+      await expect(adapter.introspect()).rejects.toThrow(OrmIntrospectionError);
+      try {
+        await adapter.introspect();
+      } catch (err) {
+        expect(err.adapter).toBe("postgresql");
+        expect(err.table).toBe("files");
+        expect(err.cause).toContain("bytea");
+      }
+    });
+    test("introspect parses foreign keys with cascade actions", async () => {
+      ;
+      adapter.pool.query = async (sql) => {
+        if (sql.includes("information_schema.tables")) {
+          return { rows: [{ table_name: "posts" }] };
+        }
+        if (sql.includes("information_schema.columns")) {
+          return {
+            rows: [
+              { column_name: "id", data_type: "text", is_nullable: "NO", column_default: null },
+              { column_name: "author_id", data_type: "text", is_nullable: "NO", column_default: null }
+            ]
+          };
+        }
+        if (sql.includes("PRIMARY KEY")) {
+          return { rows: [{ column_name: "id" }] };
+        }
+        if (sql.includes("constraint_type = 'UNIQUE'")) {
+          return { rows: [] };
+        }
+        if (sql.includes("pg_indexes")) {
+          return { rows: [] };
+        }
+        if (sql.includes("constraint_type = 'FOREIGN KEY'")) {
+          return {
+            rows: [{
+              constraint_name: "fk_posts_author_id",
+              column_name: "author_id",
+              foreign_table_name: "users",
+              foreign_column_name: "id",
+              delete_rule: "CASCADE",
+              update_rule: "SET NULL"
+            }]
+          };
+        }
+        return { rows: [] };
+      };
+      const schemas = await adapter.introspect();
+      expect(schemas[0].foreignKeys).toEqual([{
+        name: "fk_posts_author_id",
+        on: "author_id",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade",
+        onUpdate: "setNull"
+      }]);
+    });
+    test("introspect excludes tracker table from results", async () => {
+      ;
+      adapter.pool.query = async (sql, params) => {
+        if (sql.includes("information_schema.tables")) {
+          expect(params).toContain("equipped_migrations");
+          return { rows: [] };
+        }
+        return { rows: [] };
+      };
+      const schemas = await adapter.introspect();
+      expect(schemas).toEqual([]);
+    });
+    test("type-level: PostgresAdapter declares all migration methods", () => {
+      expectTypeOf(adapter.loadMigrations).toBeFunction();
+      expectTypeOf(adapter.recordMigration).toBeFunction();
+      expectTypeOf(adapter.acquireMigrationLock).toBeFunction();
+      expectTypeOf(adapter.applyCreateTable).toBeFunction();
+      expectTypeOf(adapter.applyDropTable).toBeFunction();
+      expectTypeOf(adapter.applyAddField).toBeFunction();
+      expectTypeOf(adapter.applyDropField).toBeFunction();
+      expectTypeOf(adapter.applyModifyField).toBeFunction();
+      expectTypeOf(adapter.applyRenameTable).toBeFunction();
+      expectTypeOf(adapter.applyRenameField).toBeFunction();
+      expectTypeOf(adapter.applyAddIndex).toBeFunction();
+      expectTypeOf(adapter.applyDropIndex).toBeFunction();
+      expectTypeOf(adapter.applyAddForeignKey).toBeFunction();
+      expectTypeOf(adapter.applyDropForeignKey).toBeFunction();
+      expectTypeOf(adapter.introspect).toBeFunction();
+    });
+    test("type-level: Migrator.from rejects withoutLock for PostgresAdapter", async () => {
+      const { Repo } = await null;
+      const { Migrator } = await null;
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const step = Migrator.from(repo, adapter).migrations([]);
+      expectTypeOf(step).toHaveProperty("build");
+      expectTypeOf(step).not.toHaveProperty("withoutLock");
+    });
+    test("applyCreateTable maps all field types to correct PG types", async () => {
+      await adapter.applyCreateTable({
+        kind: "createTable",
+        name: "all_types",
+        pk: { name: "id", type: "string" },
+        fields: [
+          { name: "f_num", type: "number" },
+          { name: "f_bool", type: "boolean" },
+          { name: "f_date", type: "date" },
+          { name: "f_null", type: "null" },
+          { name: "f_obj", type: "object" },
+          { name: "f_arr", type: "array" }
+        ]
+      });
+      const sql = queries[0].sql;
+      expect(sql).toContain('"f_num" double precision NOT NULL');
+      expect(sql).toContain('"f_bool" boolean NOT NULL');
+      expect(sql).toContain('"f_date" timestamptz NOT NULL');
+      expect(sql).toContain('"f_null" text NOT NULL');
+      expect(sql).toContain('"f_obj" jsonb NOT NULL');
+      expect(sql).toContain('"f_arr" jsonb NOT NULL');
+    });
+    test("applyModifyField sets NOT NULL when nullable is falsy", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "email",
+        to: { name: "email", type: "string" }
+      });
+      expect(queries[1].sql).toContain("SET NOT NULL");
+    });
+    test("applyModifyField drops default when to.default is undefined", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "age",
+        to: { name: "age", type: "number" }
+      });
+      expect(queries[2].sql).toContain("DROP DEFAULT");
+    });
+    test("applyAddField with string default escapes single quotes", async () => {
+      await adapter.applyAddField({
+        kind: "addField",
+        table: "users",
+        field: { name: "bio", type: "string", default: "it's" }
+      });
+      expect(queries[0].sql).toContain("DEFAULT 'it''s'");
+    });
+    test("end-to-end: Migrator.from(repo, adapter) wires up correctly", async () => {
+      const { Repo } = await null;
+      const { Migrator } = await null;
+      const { Schema } = await null;
+      Schema.from("users").pk("id", v.string(), () => "x").field("email", v.string()).build();
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      let loadCalls = 0;
+      const mockClient = {
+        query: async (sql, _params) => {
+          if (sql.includes("pg_advisory_lock") || sql.includes("pg_advisory_unlock")) return { rows: [] };
+          if (sql.includes("CREATE TABLE IF NOT EXISTS")) return { rows: [] };
+          if (sql.includes("SELECT id, applied_at")) {
+            loadCalls++;
+            return { rows: [] };
+          }
+          if (sql.includes("INSERT INTO")) return { rows: [] };
+          if (sql.includes("CREATE TABLE")) return { rows: [] };
+          if (sql === "BEGIN" || sql === "COMMIT" || sql === "ROLLBACK") return { rows: [] };
+          return { rows: [] };
+        },
+        release: () => {
+        }
+      };
+      adapter.pool.query = mockClient.query;
+      adapter.pool.connect = async () => mockClient;
+      const migrator = Migrator.from(repo, adapter).migrations([
+        { id: "0001", changes: [{ kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [{ name: "email", type: "string" }] }] }
+      ]).build();
+      const result = await migrator.up();
+      expect(result.ran).toEqual(["0001"]);
+      expect(loadCalls).toBe(1);
+    });
+  });
+}
+export {
+  PostgresAdapter
+};