@schemic/postgres 0.1.0-alpha.0

package/lib/index.js

@@ -0,0 +1,1161 @@
+// src/index.ts
+import {
+  connectionEntry,
+  nullable as nullable2,
+  registerDriver
+} from "@schemic/core/driver";
+
+// src/emit.ts
+import { nullable } from "@schemic/core/driver";
+var escId = (name) => `"${name.replace(/"/g, '""')}"`;
+var SCALAR_TO_PG = {
+  string: "text",
+  int: "integer",
+  float: "double precision",
+  decimal: "numeric",
+  number: "double precision",
+  bool: "boolean",
+  datetime: "timestamp with time zone",
+  uuid: "uuid",
+  bytes: "bytea",
+  duration: "interval"
+};
+function pgColumn(type) {
+  if (type.t === "option" || type.t === "nullable") {
+    return { ...pgColumn(type.inner), nullable: true };
+  }
+  if (type.t === "scalar") {
+    const sql = SCALAR_TO_PG[type.name];
+    if (!sql) throw new Error(`postgres: unsupported scalar "${type.name}"`);
+    return { sql, nullable: false };
+  }
+  if (type.t === "literal") {
+    const base = typeof type.value === "number" ? "double precision" : typeof type.value === "boolean" ? "boolean" : "text";
+    return { sql: base, nullable: false };
+  }
+  if (type.t === "union") {
+    if (type.members.every(
+      (m) => m.t === "literal" && typeof m.value === "string"
+    )) {
+      return { sql: "text", nullable: false };
+    }
+    throw new Error("postgres: non-enum unions are unsupported");
+  }
+  if (type.t === "array" || type.t === "set") {
+    const elem = pgColumn(type.elem);
+    return { sql: `${elem.sql}[]`, nullable: false };
+  }
+  if (type.t === "object") {
+    return { sql: "jsonb", nullable: false };
+  }
+  if (type.t === "record") {
+    if (type.tables.length !== 1) {
+      return { sql: "text", nullable: false };
+    }
+    return { sql: "text", nullable: false, references: type.tables[0] };
+  }
+  if (type.t === "geometry") {
+    return { sql: "jsonb", nullable: false };
+  }
+  if (type.t === "native") {
+    if (type.db !== "postgres") {
+      throw new Error(
+        `postgres: native type "${type.name}" belongs to driver "${type.db}"`
+      );
+    }
+    const params = type.params;
+    const sql = params && params.length > 0 ? `${type.name}(${params.join(", ")})` : type.name;
+    return { sql, nullable: false };
+  }
+  throw new Error(`postgres: cannot emit type ${JSON.stringify(type)}`);
+}
+function pgCanonType(type) {
+  if (type.t === "option") return nullable(pgCanonType(type.inner));
+  if (type.t === "nullable") return nullable(pgCanonType(type.inner));
+  if (type.t === "array")
+    return {
+      t: "array",
+      elem: pgCanonType(type.elem),
+      ...type.size !== void 0 ? { size: type.size } : {}
+    };
+  if (type.t === "set")
+    return {
+      t: "set",
+      elem: pgCanonType(type.elem),
+      ...type.size !== void 0 ? { size: type.size } : {}
+    };
+  if (type.t === "object") return { t: "object", fields: {} };
+  return type;
+}
+function normAction(a) {
+  const u = a?.toUpperCase();
+  return u && u !== "NO ACTION" ? u : void 0;
+}
+function canonField(f, table) {
+  const out = { name: f.name, table, type: pgCanonType(f.type) };
+  if (f.identity !== void 0) out.identity = f.identity;
+  if (f.reference) {
+    const ref = {};
+    const od = normAction(f.reference.on_delete);
+    const ou = normAction(f.reference.on_update);
+    if (od) ref.on_delete = od;
+    if (ou) ref.on_update = ou;
+    if (ref.on_delete !== void 0 || ref.on_update !== void 0)
+      out.reference = ref;
+  }
+  return out;
+}
+function pgEmitFields(t) {
+  return t.fields.filter((f) => !f.name.includes(".")).map((f) => ({ ...f, table: t.name, type: pgCanonType(f.type) })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function fkActions(ref) {
+  let s2 = "";
+  if (ref?.on_delete) s2 += ` ON DELETE ${ref.on_delete}`;
+  if (ref?.on_update) s2 += ` ON UPDATE ${ref.on_update}`;
+  return s2;
+}
+function fieldColumnDdl(f) {
+  const col = pgColumn(f.type);
+  let s2 = `${escId(f.name)} ${col.sql}`;
+  if (!col.nullable) s2 += " NOT NULL";
+  if (f.identity)
+    s2 += ` GENERATED ${f.identity === "always" ? "ALWAYS" : "BY DEFAULT"} AS IDENTITY`;
+  if (f.default !== void 0) s2 += ` DEFAULT ${f.default}`;
+  if (f.computed !== void 0)
+    s2 += ` GENERATED ALWAYS AS (${f.computed}) STORED`;
+  if (f.check !== void 0) s2 += ` CHECK (${f.check})`;
+  return s2;
+}
+function createTableDdl(t) {
+  const fields = pgEmitFields(t);
+  const custom = !!(t.primaryKey && t.primaryKey.length > 0);
+  const cols = [];
+  if (!custom) cols.push(`${escId("id")} text PRIMARY KEY`);
+  for (const f of fields) cols.push(fieldColumnDdl(f));
+  if (custom) cols.push(`PRIMARY KEY (${t.primaryKey?.map(escId).join(", ")})`);
+  for (const c of t.checks ?? []) cols.push(`CHECK (${c})`);
+  return `CREATE TABLE ${escId(t.name)} (
+  ${cols.join(",\n  ")}
+);`;
+}
+var fkName = (table, field) => `${table}_${field}_fkey`;
+var dropTableSql = (table) => `DROP TABLE IF EXISTS ${escId(table)} CASCADE;`;
+var addFkSql = (table, field, ref, actions = "") => `ALTER TABLE ${escId(table)} ADD CONSTRAINT ${escId(fkName(table, field))} FOREIGN KEY (${escId(field)}) REFERENCES ${escId(ref)} (${escId("id")})${actions};`;
+var dropFkSql = (table, field) => `ALTER TABLE ${escId(table)} DROP CONSTRAINT IF EXISTS ${escId(fkName(table, field))};`;
+
+// src/kinds.ts
+import {
+  KindRegistry
+} from "@schemic/core";
+var tableRef = (name) => ({ kind: "table", name });
+function commentLines(t) {
+  return t.fields.filter((f) => f.comment !== void 0).map(
+    (f) => `COMMENT ON COLUMN ${escId(t.name)}.${escId(f.name)} IS '${(f.comment ?? "").replace(/'/g, "''")}';`
+  );
+}
+var hasHardClause = (f) => f.identity !== void 0 || f.computed !== void 0 || f.check !== void 0;
+var sameArr = (a, b) => JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+var sameField = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var fieldKey = (table, name) => `field:${table}:${name}`;
+var createInput = (t) => ({
+  name: t.name,
+  fields: t.fields,
+  ...t.primaryKey ? { primaryKey: t.primaryKey } : {},
+  ...t.checks ? { checks: t.checks } : {}
+});
+function fieldDisplayItems(prev, next) {
+  const table = (next ?? prev)?.name ?? "";
+  const before = new Map((prev?.fields ?? []).map((f) => [f.name, f]));
+  const after = new Map((next?.fields ?? []).map((f) => [f.name, f]));
+  const items = [];
+  for (const f of next?.fields ?? [])
+    if (!before.has(f.name))
+      items.push({
+        op: "add",
+        key: fieldKey(table, f.name),
+        kind: "field",
+        table,
+        ddl: fieldColumnDdl(f)
+      });
+  for (const f of next?.fields ?? []) {
+    const b = before.get(f.name);
+    if (!b) continue;
+    if (fieldColumnDdl(b) !== fieldColumnDdl(f) || b.comment !== f.comment)
+      items.push({
+        op: "change",
+        key: fieldKey(table, f.name),
+        kind: "field",
+        table,
+        before: fieldColumnDdl(b),
+        after: fieldColumnDdl(f)
+      });
+  }
+  for (const f of prev?.fields ?? [])
+    if (!after.has(f.name))
+      items.push({
+        op: "remove",
+        key: fieldKey(table, f.name),
+        kind: "field",
+        table,
+        ddl: `ALTER TABLE ${escId(table)} DROP COLUMN IF EXISTS ${escId(f.name)};`,
+        old: fieldColumnDdl(f)
+      });
+  if (items.length === 0 && prev && next)
+    items.push({
+      op: "change",
+      key: `table:${table}:${table}`,
+      kind: "table",
+      table,
+      before: createTableDdl(createInput(prev)),
+      after: createTableDdl(createInput(next))
+    });
+  return items;
+}
+var tableEngine = {
+  // Objects arrive already in this kind's portable shape (from `explode`/`introspectAll` via splitTable
+  // / lowerSchema). `lower` is the identity — the split already produced the normalized portable object.
+  lower: (t) => t,
+  // CREATE TABLE (columns + PK + table CHECKs) followed by any column COMMENTs.
+  emit: (t) => [
+    createTableDdl({
+      name: t.name,
+      fields: t.fields,
+      ...t.primaryKey ? { primaryKey: t.primaryKey } : {},
+      ...t.checks ? { checks: t.checks } : {}
+    }),
+    ...commentLines(t)
+  ],
+  // Change-detection key (NOT the emitted DDL): the equality-relevant shape only — canonField keeps
+  // type/nullability/identity/FK-actions and DROPS the rewrite-prone/non-introspected clauses
+  // (DEFAULT/CHECK/GENERATED/COMMENT), and table-level CHECKs are omitted too. So those clauses stay
+  // faithful in `emit` (fresh apply) but never count as a change -> no phantom-diff of a freshly
+  // applied schema vs introspect (PG rewrites exprs on read; comments aren't introspected). This is
+  // the fixed-slot driver's emit/equal asymmetry, restored at the kind seam.
+  canonical: (t) => createTableDdl({
+    name: t.name,
+    fields: t.fields.map((f) => canonField(f, t.name)),
+    ...t.primaryKey ? { primaryKey: t.primaryKey } : {}
+  }),
+  // Per-FIELD display items (Manuel's decision: field-level changes grouped under their table). Each
+  // carries `table` so the CLI groups them hierarchically. DISPLAY ONLY — never affects up/down DDL.
+  // (prev,next): diff the columns; (undefined,next): list all columns as adds (the --full projection).
+  displayItems: (prev, next) => fieldDisplayItems(prev, next),
+  remove: (t) => [dropTableSql(t.name)],
+  // In-place column ALTERs (add/drop/type/nullability/default/comment). A structural change pg can't
+  // ALTER (PK, table CHECK, or a column's identity/generated/field-CHECK) falls back to drop+recreate.
+  overwrite: (prev, next) => {
+    const before = new Map(prev.fields.map((f) => [f.name, f]));
+    const after = new Map(next.fields.map((f) => [f.name, f]));
+    const changedHard = next.fields.some((f) => {
+      const b = before.get(f.name);
+      return b && (hasHardClause(f) || hasHardClause(b)) && !sameField(b, f);
+    });
+    const addedHard = next.fields.some(
+      (f) => !before.has(f.name) && hasHardClause(f)
+    );
+    const removedHard = prev.fields.some(
+      (f) => !after.has(f.name) && hasHardClause(f)
+    );
+    if (!sameArr(prev.primaryKey, next.primaryKey) || !sameArr(prev.checks, next.checks) || changedHard || addedHard || removedHard) {
+      return [...tableEngine.remove(prev), ...tableEngine.emit(next)];
+    }
+    const out = [];
+    const t = next.name;
+    for (const f of next.fields)
+      if (!before.has(f.name))
+        out.push(`ALTER TABLE ${escId(t)} ADD COLUMN ${fieldColumnDdl(f)};`);
+    for (const f of next.fields) {
+      const b = before.get(f.name);
+      if (!b) continue;
+      const ca = pgColumn(f.type);
+      const cb = pgColumn(b.type);
+      if (ca.sql !== cb.sql)
+        out.push(
+          `ALTER TABLE ${escId(t)} ALTER COLUMN ${escId(f.name)} TYPE ${ca.sql};`
+        );
+      if (ca.nullable !== cb.nullable)
+        out.push(
+          `ALTER TABLE ${escId(t)} ALTER COLUMN ${escId(f.name)} ${ca.nullable ? "DROP NOT NULL" : "SET NOT NULL"};`
+        );
+      if (f.default !== b.default)
+        out.push(
+          f.default === void 0 ? `ALTER TABLE ${escId(t)} ALTER COLUMN ${escId(f.name)} DROP DEFAULT;` : `ALTER TABLE ${escId(t)} ALTER COLUMN ${escId(f.name)} SET DEFAULT ${f.default};`
+        );
+      if (f.comment !== b.comment)
+        out.push(
+          f.comment === void 0 ? `COMMENT ON COLUMN ${escId(t)}.${escId(f.name)} IS NULL;` : `COMMENT ON COLUMN ${escId(t)}.${escId(f.name)} IS '${f.comment.replace(/'/g, "''")}';`
+        );
+    }
+    for (const f of prev.fields)
+      if (!after.has(f.name))
+        out.push(
+          `ALTER TABLE ${escId(t)} DROP COLUMN IF EXISTS ${escId(f.name)};`
+        );
+    return out;
+  }
+};
+var indexEngine = {
+  lower: (i) => i,
+  emit: (i) => [
+    `CREATE ${i.unique ? "UNIQUE " : ""}INDEX ${escId(i.name)} ON ${escId(i.table)} (${i.cols.map(escId).join(", ")});`
+  ],
+  remove: (i) => [`DROP INDEX IF EXISTS ${escId(i.name)};`],
+  // An index emits AFTER its table (deps), but NO `owner` -> no clustering: the spine then falls back
+  // to ordinal+name, so all indexes emit as a rank group after all tables (pg's emit convention),
+  // rather than clustered next to each table. owner is opt-in readability we deliberately decline.
+  deps: (i) => [tableRef(i.table)]
+  // no overwrite: an index change is a drop+recreate (the spine's default).
+};
+var constraintEngine = {
+  lower: (c) => c,
+  emit: (c) => [
+    addFkSql(
+      c.table,
+      c.column,
+      c.refTable,
+      fkActions({ on_delete: c.onDelete, on_update: c.onUpdate })
+    )
+  ],
+  remove: (c) => [dropFkSql(c.table, c.column)],
+  // A FK emits AFTER both its own table and the referenced table — this is what breaks mutual-FK
+  // cycles (tables have no deps, so they create first, then the constraints between them). NO
+  // `owner`: like the index kind, constraints emit as a rank group after all tables (pg convention).
+  deps: (c) => c.refTable === c.table ? [tableRef(c.table)] : [tableRef(c.table), tableRef(c.refTable)]
+  // no overwrite: a FK change is drop+recreate (the spine's default).
+};
+var registry = new KindRegistry();
+registry.define({
+  name: "table",
+  build: (t) => t,
+  ...tableEngine
+});
+registry.define({
+  name: "index",
+  build: (i) => i,
+  ...indexEngine
+});
+registry.define({
+  name: "constraint",
+  build: (c) => c,
+  ...constraintEngine
+});
+function splitTable(t) {
+  const out = [];
+  const fields = pgEmitFields(t);
+  const table = {
+    kind: "table",
+    name: t.name,
+    fields,
+    ...t.primaryKey && t.primaryKey.length > 0 ? { primaryKey: t.primaryKey } : {},
+    ...t.checks && t.checks.length > 0 ? { checks: t.checks } : {}
+  };
+  out.push(table);
+  for (const ix of t.indexes) {
+    const index = {
+      kind: "index",
+      name: ix.name,
+      table: t.name,
+      cols: ix.cols,
+      unique: ix.unique
+    };
+    out.push(index);
+  }
+  for (const f of fields) {
+    const ref = pgColumn(f.type).references;
+    if (!ref) continue;
+    const onDelete = normAction(f.reference?.on_delete);
+    const onUpdate = normAction(f.reference?.on_update);
+    const fk = {
+      kind: "constraint",
+      name: fkName(t.name, f.name),
+      table: t.name,
+      ctype: "fk",
+      column: f.name,
+      refTable: ref,
+      ...onDelete ? { onDelete } : {},
+      ...onUpdate ? { onUpdate } : {}
+    };
+    out.push(fk);
+  }
+  return out;
+}
+var splitTables = (tables) => tables.flatMap(splitTable);
+
+// src/lower.ts
+var defOf = (schema) => schema._zod.def;
+var CANON = {
+  text: "string",
+  integer: "int",
+  "double precision": "float",
+  numeric: "decimal",
+  boolean: "bool",
+  timestamptz: "datetime",
+  uuid: "uuid",
+  bytea: "bytes",
+  interval: "duration"
+};
+function tokenToPortable(type, params) {
+  if (type === "jsonb") return { t: "object", fields: {} };
+  if (params && params.length > 0)
+    return { t: "native", db: "postgres", name: type, params };
+  const scalar = CANON[type];
+  return scalar ? { t: "scalar", name: scalar } : { t: "native", db: "postgres", name: type };
+}
+function structure(schema) {
+  const wrappers = [];
+  let cur = schema;
+  for (; ; ) {
+    const def = defOf(cur);
+    if (def.type === "optional" && def.innerType) {
+      wrappers.push("option");
+      cur = def.innerType;
+    } else if (def.type === "nullable" && def.innerType) {
+      wrappers.push("nullable");
+      cur = def.innerType;
+    } else if (def.type === "array" && def.element) {
+      wrappers.push("array");
+      cur = def.element;
+    } else if ((def.type === "default" || def.type === "prefault" || def.type === "catch" || def.type === "readonly") && def.innerType) {
+      cur = def.innerType;
+    } else {
+      break;
+    }
+  }
+  return { wrappers, leaf: cur };
+}
+function leafPortable(meta) {
+  if (meta.references) return { t: "record", tables: [meta.references.table] };
+  if (!meta.pg) return { t: "scalar", name: "string" };
+  return tokenToPortable(meta.pg.type, meta.pg.params);
+}
+function portableType(meta, wrappers) {
+  let type = leafPortable(meta);
+  for (let i = wrappers.length - 1; i >= 0; i--) {
+    const w = wrappers[i];
+    type = w === "array" ? { t: "array", elem: type } : w === "option" ? { t: "option", inner: type } : { t: "nullable", inner: type };
+  }
+  return type;
+}
+function lowerField(name, table, field) {
+  const meta = field.native;
+  const { wrappers } = structure(field.schema);
+  const pf = {
+    name,
+    table,
+    type: portableType(meta, wrappers)
+  };
+  if (meta.default !== void 0) pf.default = meta.default;
+  if (meta.check !== void 0) pf.check = meta.check;
+  if (meta.generated !== void 0) pf.computed = meta.generated;
+  if (meta.identity !== void 0) pf.identity = meta.identity;
+  if (meta.comment !== void 0) pf.comment = meta.comment;
+  if (meta.references) {
+    const ref = {};
+    if (meta.references.onDelete) ref.on_delete = meta.references.onDelete;
+    if (meta.references.onUpdate) ref.on_update = meta.references.onUpdate;
+    if (ref.on_delete !== void 0 || ref.on_update !== void 0)
+      pf.reference = ref;
+  }
+  return pf;
+}
+function lowerTable(def) {
+  const fields = [];
+  const indexes = [];
+  const pkCols = [...def.config.primaryKey ?? []];
+  for (const [name, field] of Object.entries(def.fields)) {
+    fields.push(lowerField(name, def.name, field));
+    if (field.native.unique)
+      indexes.push({
+        name: `${def.name}_${name}_key`,
+        cols: [name],
+        unique: true
+      });
+    if (field.native.primaryKey && !pkCols.includes(name)) pkCols.push(name);
+  }
+  for (const ix of def.config.indexes ?? []) {
+    indexes.push({
+      name: ix.name ?? `${def.name}_${ix.cols.join("_")}_idx`,
+      cols: ix.cols,
+      unique: !!ix.unique
+    });
+  }
+  const table = { name: def.name, fields, indexes };
+  if (pkCols.length > 0) table.primaryKey = pkCols;
+  if (def.config.checks && def.config.checks.length > 0)
+    table.checks = def.config.checks;
+  return table;
+}
+function pgLower(tables) {
+  return tables.map(lowerTable);
+}
+
+// src/authoring.ts
+import {
+  SFieldBase,
+  toZod
+} from "@schemic/core/authoring";
+import * as z from "zod";
+var blankMeta = () => ({});
+var sqlExpr = (sql) => ({ __sql: sql });
+var isSqlExpr = (v) => typeof v === "object" && v !== null && "__sql" in v;
+function pgLiteral(v) {
+  if (v === null) return "NULL";
+  if (typeof v === "number") return String(v);
+  if (typeof v === "boolean") return v ? "true" : "false";
+  return `'${v.replace(/'/g, "''")}'`;
+}
+var toExpr = (v) => isSqlExpr(v) ? v.__sql : pgLiteral(v);
+var PgField = class _PgField extends SFieldBase {
+  rebuild(schema, native) {
+    return new _PgField(schema, native);
+  }
+  blank() {
+    return blankMeta();
+  }
+  with(meta) {
+    return new _PgField(this.schema, { ...this.native, ...meta });
+  }
+  // --- pg-native `$`-methods (DDL authoring) ---
+  /** `DEFAULT <value>` — a JS literal, or `sqlExpr("now()")` for a raw SQL default. */
+  $default(value) {
+    return this.with({ default: toExpr(value) });
+  }
+  /** Field-level `CHECK (<expr>)`. */
+  $check(expr) {
+    return this.with({ check: isSqlExpr(expr) ? expr.__sql : expr });
+  }
+  /** `GENERATED ALWAYS AS (<expr>) STORED` — a computed column. */
+  $generated(expr) {
+    return this.with({ generated: isSqlExpr(expr) ? expr.__sql : expr });
+  }
+  /** `GENERATED {ALWAYS|BY DEFAULT} AS IDENTITY` (auto-increment). */
+  $identity(mode = "by-default") {
+    return this.with({ identity: mode });
+  }
+  /** Column-level `UNIQUE`. */
+  $unique() {
+    return this.with({ unique: true });
+  }
+  /** Mark this column (part of) the PRIMARY KEY. */
+  $primaryKey() {
+    return this.with({ primaryKey: true });
+  }
+  /** Foreign key to `table(id)` with optional `ON DELETE`/`ON UPDATE` actions. */
+  $references(table, opts) {
+    return this.with({ references: { table, ...opts ?? {} } });
+  }
+  /** `COMMENT ON COLUMN`. */
+  $comment(text) {
+    return this.with({ comment: text });
+  }
+  /**
+   * ESCAPE HATCH (chainable form) — teach the driver how to STORE this field's value in Postgres:
+   * give the **wire type** as an `s.*`/Zod field (its pg column type is taken from it) plus a codec
+   * (`encode`: app -> wire, `decode`: wire -> app). This turns an otherwise-unmappable App value
+   * (e.g. `s.instanceof(Money)`) into a real pg column. Omit the codec for an identity mapping (the
+   * app value is stored as-is). Mirrors SurrealDB's `.$surreal(wire, codec)`; the standalone
+   * {@link s.$postgres} factory is the from-scratch equivalent. `$`-prefixed to avoid clashing with Zod.
+   */
+  $postgres(wire, codec2) {
+    const wireSchema = toZod(wire);
+    const c = z.codec(wireSchema, this.schema, {
+      decode: (w) => codec2 ? codec2.decode(w) : w,
+      encode: (a) => codec2 ? codec2.encode(a) : a
+    });
+    const wirePg = wire instanceof _PgField ? wire.native.pg : void 0;
+    return new _PgField(c, {
+      ...this.native,
+      ...wirePg ? { pg: wirePg } : {}
+    });
+  }
+};
+var mk = (type, schema, params) => new PgField(schema, { pg: params ? { type, params } : { type } });
+var s = {
+  // Zod drop-ins (the canonical superset; each maps to a sensible pg default). Native aliases below
+  // (text/varchar/int/numeric/…) give precise control.
+  string: () => mk("text", z.string()),
+  number: () => mk("double precision", z.number()),
+  // text
+  text: () => mk("text", z.string()),
+  varchar: (n) => n === void 0 ? mk("varchar", z.string()) : mk("varchar", z.string().max(n), [n]),
+  char: (n) => n === void 0 ? mk("char", z.string()) : mk("char", z.string(), [n]),
+  citext: () => mk("citext", z.string()),
+  // numeric
+  smallint: () => mk("smallint", z.int().gte(-32768).lte(32767)),
+  integer: () => mk("integer", z.int()),
+  int: () => mk("integer", z.int()),
+  bigint: () => mk("bigint", z.int()),
+  serial: () => mk("integer", z.int()).$identity("by-default"),
+  bigserial: () => mk("bigint", z.int()).$identity("by-default"),
+  numeric: (precision, scale) => precision === void 0 ? mk("numeric", z.number()) : (
+    // Postgres stores `numeric(p)` as `numeric(p,0)`; keep scale explicit so it round-trips.
+    mk("numeric", z.number(), [precision, scale ?? 0])
+  ),
+  decimal: (precision, scale) => s.numeric(precision, scale),
+  real: () => mk("real", z.number()),
+  doublePrecision: () => mk("double precision", z.number()),
+  float: () => mk("double precision", z.number()),
+  money: () => mk("money", z.string()),
+  // boolean
+  boolean: () => mk("boolean", z.boolean()),
+  bool: () => mk("boolean", z.boolean()),
+  // temporal
+  timestamptz: () => mk("timestamptz", z.date()),
+  timestamp: () => mk("timestamp", z.date()),
+  date: () => mk("date", z.date()),
+  time: () => mk("time", z.string()),
+  timetz: () => mk("timetz", z.string()),
+  interval: () => mk("interval", z.string()),
+  // identity / network / uuid / bytes
+  uuid: () => mk("uuid", z.uuid()),
+  bytea: () => mk("bytea", z.instanceof(Uint8Array)),
+  inet: () => mk("inet", z.string()),
+  cidr: () => mk("cidr", z.string()),
+  macaddr: () => mk("macaddr", z.string()),
+  // json
+  jsonb: (shape) => mk("jsonb", shape ?? z.unknown()),
+  json: (shape) => mk("json", shape ?? z.unknown()),
+  // enum (string-literal union -> text) and single literal
+  enum: (values) => mk("text", z.enum(values)),
+  literal: (value) => mk(
+    typeof value === "number" ? "double precision" : typeof value === "boolean" ? "boolean" : "text",
+    z.literal(value)
+  ),
+  // object -> jsonb (opaque on disk). Accepts field OR raw-Zod values (a Zod drop-in superset).
+  object: (shape) => mk(
+    "jsonb",
+    z.object(
+      Object.fromEntries(
+        Object.entries(shape).map(([k, v]) => [k, toZod(v)])
+      )
+    )
+  ),
+  // array(elem) -> `<elem>[]`; carries the element's pg metadata so it lowers to an array of that type.
+  array: (elem) => new PgField(
+    z.array(toZod(elem)),
+    elem instanceof PgField ? elem.native : {}
+  ),
+  // foreign key: `text` column + FK to `table(id)`
+  references: (table, opts) => new PgField(z.string(), {
+    pg: { type: "text" },
+    references: { table, ...opts ?? {} }
+  }),
+  /**
+   * ESCAPE HATCH — a pg type with no portable meaning, stored via a Zod codec (encode/decode). The
+   * column is emitted as `pgType`; App-side reads/writes go through `codec`. Mirrors surreal `$surreal`.
+   */
+  $postgres: (pgType, codec2) => new PgField(codec2, { pg: { type: pgType } })
+};
+var PgTableDef = class _PgTableDef {
+  constructor(name, fields, config = {}) {
+    this.name = name;
+    this.fields = fields;
+    this.config = config;
+  }
+  /** Composite / custom PRIMARY KEY (overrides the implicit `id`). */
+  primaryKey(...cols) {
+    return new _PgTableDef(this.name, this.fields, {
+      ...this.config,
+      primaryKey: cols
+    });
+  }
+  /** A table-level `CHECK (<expr>)`. */
+  check(expr) {
+    return new _PgTableDef(this.name, this.fields, {
+      ...this.config,
+      checks: [...this.config.checks ?? [], expr]
+    });
+  }
+  /** A secondary index over `cols` (optionally `UNIQUE`). */
+  index(cols, opts) {
+    return new _PgTableDef(this.name, this.fields, {
+      ...this.config,
+      indexes: [...this.config.indexes ?? [], { cols, ...opts ?? {} }]
+    });
+  }
+  /**
+   * A foreign-key field referencing THIS table (for use in another table's shape):
+   * `author: user.record({ onDelete: "cascade" })`. Also satisfies the CLI's structural table check.
+   */
+  record(opts) {
+    return s.references(this.name, opts);
+  }
+};
+function defineTable(name, fields, config) {
+  return new PgTableDef(name, fields, config ?? {});
+}
+
+// src/index.ts
+var nativeT = (name, params) => params && params.length > 0 ? { t: "native", db: "postgres", name, params } : { t: "native", db: "postgres", name };
+var scalarT = (name) => ({ t: "scalar", name });
+var DATATYPE_TO_SCALAR = {
+  text: "string",
+  integer: "int",
+  "double precision": "float",
+  boolean: "bool",
+  uuid: "uuid",
+  bytea: "bytes",
+  interval: "duration"
+};
+var DATATYPE_TO_NATIVE = {
+  "time without time zone": "time",
+  "time with time zone": "timetz"
+};
+function introspectType(c) {
+  const dt = c.data_type;
+  if (dt === "ARRAY") {
+    return { t: "array", elem: pgScalarFromUdt(c.udt_name.replace(/^_/, "")) };
+  }
+  if (dt === "jsonb") return { t: "object", fields: {} };
+  if (dt === "json") return nativeT("json");
+  if (dt === "character varying")
+    return c.character_maximum_length != null ? nativeT("varchar", [c.character_maximum_length]) : nativeT("varchar");
+  if (dt === "character")
+    return c.character_maximum_length != null ? nativeT("char", [c.character_maximum_length]) : nativeT("char");
+  if (dt === "numeric")
+    return c.numeric_precision != null ? nativeT("numeric", [c.numeric_precision, c.numeric_scale ?? 0]) : scalarT("decimal");
+  if (dt === "timestamp without time zone") return nativeT("timestamp");
+  if (dt === "timestamp with time zone") return scalarT("datetime");
+  const sc = DATATYPE_TO_SCALAR[dt];
+  if (sc) return scalarT(sc);
+  return nativeT(DATATYPE_TO_NATIVE[dt] ?? dt);
+}
+var UDT_TO_SCALAR = {
+  text: "string",
+  int4: "int",
+  float8: "float",
+  numeric: "decimal",
+  bool: "bool",
+  timestamptz: "datetime",
+  uuid: "uuid",
+  bytea: "bytes",
+  interval: "duration"
+};
+function pgScalarFromUdt(udt) {
+  const name = UDT_TO_SCALAR[udt];
+  return name ? { t: "scalar", name } : { t: "native", db: "postgres", name: udt };
+}
+async function pgIntrospect(conn, exclude = /* @__PURE__ */ new Set()) {
+  const skip = new Set(exclude);
+  for (const t of exclude) skip.add(`${t}_lock`);
+  const { rows: cols } = await conn.query(
+    `SELECT table_name, column_name, data_type, udt_name, is_nullable,
+            is_identity, identity_generation,
+            character_maximum_length, numeric_precision, numeric_scale
+       FROM information_schema.columns
+      WHERE table_schema = 'public'
+      ORDER BY table_name, ordinal_position`
+  );
+  const { rows: fks } = await conn.query(
+    `SELECT tc.table_name, kcu.column_name, ccu.table_name AS foreign_table_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 ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+       JOIN information_schema.referential_constraints rc
+         ON rc.constraint_name = tc.constraint_name AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = 'public'`
+  );
+  const { rows: pks } = await conn.query(
+    `SELECT tc.table_name, 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.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'
+      ORDER BY kcu.ordinal_position`
+  );
+  const { rows: idxs } = await conn.query(
+    `SELECT t.relname AS table_name, i.relname AS index_name, a.attname AS column_name,
+            ix.indisunique AS is_unique
+       FROM pg_class t
+       JOIN pg_namespace n ON n.oid = t.relnamespace AND n.nspname = 'public'
+       JOIN pg_index ix ON ix.indrelid = t.oid AND NOT ix.indisprimary
+            AND ix.indpred IS NULL AND ix.indexprs IS NULL
+       JOIN pg_class i ON i.oid = ix.indexrelid
+       JOIN pg_am am ON am.oid = i.relam AND am.amname = 'btree'
+       JOIN LATERAL unnest(string_to_array(ix.indkey::text, ' ')::int[])
+            WITH ORDINALITY AS k(attnum, ord) ON true
+       JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+      WHERE t.relkind = 'r'
+      ORDER BY t.relname, i.relname, k.ord`
+  );
+  const fkBy = /* @__PURE__ */ new Map();
+  for (const f of fks) fkBy.set(`${f.table_name}.${f.column_name}`, f);
+  const pkBy = /* @__PURE__ */ new Map();
+  for (const p of pks) {
+    const list = pkBy.get(p.table_name) ?? [];
+    list.push(p.column_name);
+    pkBy.set(p.table_name, list);
+  }
+  const idColBy = /* @__PURE__ */ new Map();
+  for (const c of cols)
+    if (c.column_name === "id") idColBy.set(c.table_name, c);
+  const isImplicit = (table) => {
+    const pk = pkBy.get(table);
+    if (!(pk?.length === 1 && pk[0] === "id")) return false;
+    const id = idColBy.get(table);
+    return !!id && id.data_type === "text" && id.is_identity !== "YES";
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const byTable = /* @__PURE__ */ new Map();
+  for (const c of cols) {
+    if (skip.has(c.table_name)) continue;
+    seen.add(c.table_name);
+    if (c.column_name === "id" && isImplicit(c.table_name)) continue;
+    const fk = fkBy.get(`${c.table_name}.${c.column_name}`);
+    let type = fk ? { t: "record", tables: [fk.foreign_table_name] } : introspectType(c);
+    if (c.is_nullable === "YES") type = nullable2(type);
+    const pf = {
+      name: c.column_name,
+      table: c.table_name,
+      type
+    };
+    if (c.is_identity === "YES")
+      pf.identity = c.identity_generation === "ALWAYS" ? "always" : "by-default";
+    if (fk) {
+      const ref = {};
+      if (fk.delete_rule && fk.delete_rule !== "NO ACTION")
+        ref.on_delete = fk.delete_rule;
+      if (fk.update_rule && fk.update_rule !== "NO ACTION")
+        ref.on_update = fk.update_rule;
+      if (ref.on_delete !== void 0 || ref.on_update !== void 0)
+        pf.reference = ref;
+    }
+    const list = byTable.get(c.table_name) ?? [];
+    list.push(pf);
+    byTable.set(c.table_name, list);
+  }
+  const idxBy = /* @__PURE__ */ new Map();
+  for (const r of idxs) {
+    if (skip.has(r.table_name)) continue;
+    const byName = idxBy.get(r.table_name) ?? /* @__PURE__ */ new Map();
+    const ix = byName.get(r.index_name) ?? {
+      name: r.index_name,
+      cols: [],
+      unique: r.is_unique
+    };
+    ix.cols.push(r.column_name);
+    byName.set(r.index_name, ix);
+    idxBy.set(r.table_name, byName);
+  }
+  return [...seen].map((name) => {
+    const t = {
+      name,
+      fields: byTable.get(name) ?? [],
+      indexes: [...idxBy.get(name)?.values() ?? []]
+    };
+    if (!isImplicit(name)) {
+      const pk = pkBy.get(name);
+      if (pk && pk.length > 0) t.primaryKey = pk;
+    }
+    return t;
+  });
+}
+async function newPglite(dataDir) {
+  const pkg = "@electric-sql/pglite";
+  let PGlite;
+  try {
+    const mod = await import(pkg);
+    PGlite = mod.PGlite;
+  } catch {
+    PGlite = void 0;
+  }
+  if (!PGlite) {
+    throw new Error(
+      "postgres driver needs `@electric-sql/pglite` (embedded) \u2014 install it, or wire a node-postgres client."
+    );
+  }
+  return new PGlite(dataDir);
+}
+var shadow = {
+  // A throwaway in-memory PGlite IS the shadow: apply the DDL, read it back as kind objects, done (no
+  // drop needed — the instance is discarded). This is the "embedded engine" canonicalization path.
+  async roundTrip(_conn, _config, ddl) {
+    const scratch = await newPglite();
+    try {
+      if (ddl.trim()) await scratch.exec(ddl);
+      return splitTables(await pgIntrospect(scratch));
+    } finally {
+      await scratch.close();
+    }
+  },
+  async ephemeral() {
+    const conn = await newPglite();
+    return { conn, stop: () => conn.close() };
+  }
+};
+var isFragment = (v) => typeof v === "object" && v !== null && "__pgRaw" in v;
+var isBound = (v) => typeof v === "object" && v !== null && typeof v.query === "string" && Array.isArray(v.params);
+function raw(sql) {
+  return { __pgRaw: sql };
+}
+function identifier(name) {
+  return { __pgRaw: escId(name) };
+}
+function pgSql(strings, ...values) {
+  let query = "";
+  const params = [];
+  strings.forEach((str, i) => {
+    query += str;
+    if (i >= values.length) return;
+    const v = values[i];
+    if (isFragment(v)) {
+      query += v.__pgRaw;
+    } else if (isBound(v)) {
+      query += v.query.replace(
+        /\$(\d+)/g,
+        (_m, n) => `$${params.length + Number(n)}`
+      );
+      params.push(...v.params);
+    } else {
+      params.push(v);
+      query += `$${params.length}`;
+    }
+  });
+  return { query, params };
+}
+function postgresConnection(input) {
+  return connectionEntry("postgres", input);
+}
+var MIG_UP = "-- schemic:up";
+var MIG_DOWN = "-- schemic:down";
+function renderMigration(_tag, diff) {
+  return `${MIG_UP}
+${diff.up.join("\n")}
+
+${MIG_DOWN}
+${diff.down.join("\n")}
+`;
+}
+function migSection(content, direction) {
+  const up = content.indexOf(MIG_UP);
+  const down = content.indexOf(MIG_DOWN);
+  if (up === -1 || down === -1) return direction === "up" ? content : "";
+  return direction === "up" ? content.slice(up + MIG_UP.length, down) : content.slice(down + MIG_DOWN.length);
+}
+var sqlStr = (v) => `'${v.replace(/'/g, "''")}'`;
+var lockTableOf = (table) => `${table}_lock`;
+async function ensureMigTable(conn, table) {
+  await conn.exec(
+    `CREATE TABLE IF NOT EXISTS ${escId(table)} (
+  ${escId("tag")} text PRIMARY KEY,
+  ${escId("file")} text NOT NULL,
+  ${escId("checksum")} text NOT NULL,
+  ${escId("applied_at")} timestamptz NOT NULL DEFAULT now()
+);`
+  );
+}
+var recordInsert = (table, r) => `INSERT INTO ${escId(table)} (${escId("tag")}, ${escId("file")}, ${escId("checksum")}) VALUES (${sqlStr(r.tag)}, ${sqlStr(r.file)}, ${sqlStr(r.checksum)});`;
+var migrations = {
+  extension: ".sql",
+  render: renderMigration,
+  ensure: ensureMigTable,
+  async applied(conn, table) {
+    const { rows } = await conn.query(
+      `SELECT ${escId("tag")}, ${escId("checksum")} FROM ${escId(table)};`
+    );
+    return new Map(rows.map((r) => [r.tag, r.checksum]));
+  },
+  // Postgres runs DDL inside a transaction, so the migration's section + its bookkeeping write commit
+  // atomically — the record lands iff the DDL applied.
+  async apply(conn, table, { content, direction, record }) {
+    const ddl = migSection(content, direction).trim();
+    const book = direction === "up" ? recordInsert(table, record) : `DELETE FROM ${escId(table)} WHERE ${escId("tag")} = ${sqlStr(record.tag)};`;
+    await conn.exec(`BEGIN;
+${ddl ? `${ddl}
+` : ""}${book}
+COMMIT;`);
+  },
+  async record(conn, table, record) {
+    await ensureMigTable(conn, table);
+    await conn.exec(recordInsert(table, record));
+  },
+  async clear(conn, table) {
+    await conn.exec(`DELETE FROM ${escId(table)};`);
+  },
+  // A persisted lock ROW (survives across separate CLI runs on a file-based PGlite, unlike a session
+  // advisory lock). The PK collision on a held lock is the "already locked" signal.
+  async lock(conn, table) {
+    const lt = lockTableOf(table);
+    await conn.exec(
+      `CREATE TABLE IF NOT EXISTS ${escId(lt)} (${escId("id")} int PRIMARY KEY);`
+    );
+    try {
+      await conn.exec(`INSERT INTO ${escId(lt)} (${escId("id")}) VALUES (1);`);
+    } catch {
+      throw new Error(
+        "Migrations are locked \u2014 another run is in progress. If it's stale, run `schemic unlock`."
+      );
+    }
+  },
+  async unlock(conn, table) {
+    const lt = lockTableOf(table);
+    await conn.exec(
+      `CREATE TABLE IF NOT EXISTS ${escId(lt)} (${escId("id")} int PRIMARY KEY);
+DELETE FROM ${escId(lt)} WHERE ${escId("id")} = 1;`
+    );
+  }
+};
+var postgresDriver = {
+  name: "postgres",
+  // The kind registry (table/index/constraint) — core runs lower/diff/emit/order generically over it.
+  registry,
+  // Authoring (pg-native `defineTable` -> PgTableDef) -> kinded Definables: lower each table to the
+  // driver's `PgTable` IR (./lower.ts), then split it into [table, ...index, ...constraint] objects
+  // (./kinds.ts splitTable). Core then runs lowerSchema(registry, explode(...)). pg has no standalone
+  // defs, so `defs` is unused.
+  explode: (tables) => splitTables(pgLower(tables)),
+  // One information_schema/pg_catalog read -> ALL kind objects, canonicalized identically to lowering
+  // (a clean apply round-trips to a zero diff) and complete (table + index + FK), so no phantom diffs.
+  introspectAll: async (conn, exclude) => splitTables(await pgIntrospect(conn, exclude)),
+  /**
+   * Raw READ query for connection RESOLVERS + seed (returns rows opaquely). Postgres binds
+   * POSITIONALLY, so the uniform `vars` record is mapped onto `$1..$n`: a string with NAMED `$name`
+   * placeholders + `vars` is rewritten to positional `$1..$n` with `vars` bound by name (never
+   * string-interpolated); native numeric `$1` is left untouched; no `vars` -> run as-is. To build a
+   * query safely from interpolated values, use {@link pgSql} (positional) and run it via the raw
+   * connection: `conn.query(q.query, q.params)` — that also avoids rewriting `$` inside string literals.
+   */
+  async query(conn, sql, vars) {
+    if (!vars || Object.keys(vars).length === 0) {
+      return (await conn.query(sql)).rows;
+    }
+    const params = [];
+    const text = sql.replace(
+      /\$([A-Za-z_][A-Za-z0-9_]*)/g,
+      (_m, name) => {
+        if (!(name in vars)) {
+          throw new Error(`postgres query: no binding for $${name}`);
+        }
+        params.push(vars[name]);
+        return `$${params.length}`;
+      }
+    );
+    return (await conn.query(text, params)).rows;
+  },
+  connect(config, _over) {
+    const url = typeof config.params.url === "string" ? config.params.url : "";
+    const dir = url.startsWith("file:") ? url.slice("file:".length) : void 0;
+    return newPglite(dir);
+  },
+  async apply(conn, statements, opts) {
+    if (!statements.length) return;
+    const body = statements.join("\n");
+    if (opts?.transactional === false) {
+      await conn.exec(body);
+      return;
+    }
+    await conn.exec(`BEGIN;
+${body}
+COMMIT;`);
+  },
+  close(conn) {
+    return conn.close();
+  },
+  // Apply-time migration bookkeeping (the `_migrations` table SQL behind migrate/rollback/status).
+  migrations,
+  // `schemic init --driver postgres` scaffolds a real connections-only pg project from these files
+  // (the CLI adds the neutral migration snapshot).
+  initScaffold: () => ({
+    "schemic.config.ts": INIT_CONFIG_TS,
+    "database/schema/tables.ts": INIT_SCHEMA_TS,
+    "database/seed.ts": INIT_SEED_TS,
+    ".env.example": INIT_ENV
+  }),
+  // `schemic new <kind> <name>` -> the starter authoring module for a new entity. pg's only
+  // standalone definable is the `table`; indexes/FKs are authored INSIDE a table, so those kinds
+  // throw with guidance. The CLI writes the returned text under registry.display(kind).folder.
+  scaffoldEntity: (kind, name) => scaffoldPgEntity(kind, name),
+  shadow
+};
+var INIT_CONFIG_TS = `import { defineConfig } from "@schemic/core/config";
+import { postgresConnection } from "@schemic/postgres";
+
+// Connections-only config: a map of named connections, each from a driver factory. Values are
+// explicit \u2014 read env yourself (no magic env vars).
+export default defineConfig({
+  connections: {
+    default: postgresConnection({
+      schema: "./database/schema",
+      // PGlite (embedded): \`file:<dir>\` is a persistent data dir; "" is in-memory. Point
+      // DATABASE_URL at a real server (\`postgres://\u2026\`) once the node-postgres client lands.
+      url: process.env.DATABASE_URL ?? "file:./.pgdata",
+    }),
+  },
+});
+`;
+var INIT_SCHEMA_TS = `import { defineTable, s, sqlExpr } from "@schemic/postgres";
+
+export const user = defineTable("user", {
+  email: s.varchar(255).$unique(),
+  name: s.text(),
+  age: s.smallint().optional(),
+  createdAt: s.timestamptz().$default(sqlExpr("now()")),
+});
+`;
+var INIT_SEED_TS = `// Seed script \u2014 run with \`schemic seed\`. Receives the live connection(s).
+export default async function seed() {
+  // await conn.query("INSERT INTO ...");
+}
+`;
+var INIT_ENV = `# A real Postgres server (uncomment to use instead of embedded PGlite):
+# DATABASE_URL=postgres://user:pass@localhost:5432/app
+`;
+function toIdentifier(name) {
+  const camel = name.replace(
+    /[^a-zA-Z0-9_$]+([a-zA-Z0-9])?/g,
+    (_m, c) => c ? c.toUpperCase() : ""
+  );
+  return /^[0-9]/.test(camel) ? `_${camel}` : camel || "entity";
+}
+function scaffoldTable(name) {
+  const ident = toIdentifier(name);
+  return `import { defineTable, s, sqlExpr } from "@schemic/postgres";
+
+// \`sc new table ${name}\` scaffolded this. Author your columns, then \`sc gen\`.
+export const ${ident} = defineTable(${JSON.stringify(name)}, {
+  // An implicit \`"id" text PRIMARY KEY\` is added unless you declare a PK below.
+  name: s.text(),
+  // email: s.varchar(255).$unique(),                              // -> UNIQUE INDEX
+  // age: s.smallint().optional(),                                 // -> nullable column
+  // status: s.text().$check("status in ('active', 'archived')"),  // -> CHECK constraint
+  // owner: s.references("other_table", { onDelete: "cascade" }),  // -> FOREIGN KEY
+  createdAt: s.timestamptz().$default(sqlExpr("now()")),
+});
+// Table-level options (chain onto defineTable(...) above):
+//   .primaryKey("a", "b")   composite PK (drops the implicit id)
+//   .check("age >= 0")      table-level CHECK
+//   .index(["name"])        secondary index (add { unique: true } for UNIQUE)
+`;
+}
+function scaffoldPgEntity(kind, name) {
+  switch (kind) {
+    case "table":
+      return scaffoldTable(name);
+    case "index":
+    case "constraint":
+      throw new Error(
+        `postgres: "${kind}" isn't a standalone entity \u2014 indexes and foreign keys are authored inside a table (defineTable(...).index([...]) / s.references(...)). Run \`sc new table <name>\`.`
+      );
+    default:
+      throw new Error(
+        `postgres: unknown entity kind "${kind}" \u2014 pg scaffolds: table.`
+      );
+  }
+}
+registerDriver(postgresDriver);
+export {
+  PgField,
+  PgTableDef,
+  defineTable,
+  identifier,
+  pgSql,
+  postgresConnection,
+  postgresDriver,
+  raw,
+  s,
+  sqlExpr
+};
+//# sourceMappingURL=index.js.map