okmodel 0.1.1 → 0.3.0

package/dist/shared/{yd1kzwn2.js → jns2wx4t.js}

@@ -1,16 +1,24 @@
+import {
+  touchFields,
+  fieldSealed
+} from "./7m88x3e9.js";
 import {
   projectExpr,
   quote,
   list,
   isRecord,
+  registerFailFix,
   fail
-} from "./rgs0st28.js";
+} from "./xrfnq5k8.js";
 import {
   throwNamed2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/runtime/conflict.ts
-function readConflict(table, value) {
+registerFailFix("OKM1104", "Set on to the columns of a unique constraint or the primary key.");
+registerFailFix("OKM1190", "Remove the guarded field. Input cannot set it.");
+var NO_ALLOW = new Set;
+function readConflict(table, value, allow = NO_ALLOW) {
   if (value === undefined || value === "error")
     return;
   if (value === "ignore")
@@ -33,7 +41,7 @@ function readConflict(table, value) {
     return {
       kind: "update",
       columns: uniqueColumns(table, value.on),
-      update: updateColumns(table, update)
+      update: updateColumns(table, update, allow)
     };
   }
   fail("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
@@ -44,9 +52,17 @@ function finishInsert(head, returning, params, plan, table, returningColumns, ke
   }
   const target = plan.columns.map((column) => quote(column.sql)).join(", ");
   if (plan.kind === "update") {
-    const set = plan.update.map((column) => `${quote(column.sql)} = excluded.${quote(column.sql)}`).join(", ");
+    const assignments = plan.update.map((column) => `${quote(column.sql)} = excluded.${quote(column.sql)}`);
+    const touch = touchFields(table.model);
+    if (touch !== undefined) {
+      for (const field of touch) {
+        const column = table.columns.get(field);
+        if (column !== undefined)
+          assignments.push(`${quote(column.sql)} = now()`);
+      }
+    }
     return {
-      text: `${head} on conflict (${target}) do update set ${set}${returning}`,
+      text: `${head} on conflict (${target})${conflictWhere(table, plan.columns)} do update set ${assignments.join(", ")}${returning}`,
       params: [...params]
     };
   }
@@ -71,9 +87,29 @@ function firstOrCreate(head, returning, params, keys, table, returningColumns, k
   const names = returningColumns.map((column) => quote(column.field)).join(", ");
   const fromTable = returningColumns.map((column) => projectExpr(`t.${quote(column.sql)}`, column.dataType)).join(", ");
   const match = keys.map((column) => `ins.${quote(column.field)} = t.${quote(column.sql)}`).join(" and ");
-  const text = `with ins(${names}) as (${head} on conflict (${keyList}) do nothing${returning}) select ${names} from ins union all select ${fromTable} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")}) and not exists (select 1 from ins where ${match})`;
+  const text = `with ins(${names}) as (${head} on conflict (${keyList})${conflictWhere(table, keys)} do nothing${returning}) select ${names} from ins union all select ${fromTable} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")}) and not exists (select 1 from ins where ${match})`;
   return { text, params: next };
 }
+function conflictWhere(table, columns) {
+  const archive = table.model.archive;
+  if (archive === undefined || samePrimary(table, columns))
+    return "";
+  return ` where ${quote(archive.at)} is null`;
+}
+function samePrimary(table, columns) {
+  const primary = table.model.primary;
+  if (columns.length !== primary.length)
+    return false;
+  for (const field of primary) {
+    let found = false;
+    for (const column of columns)
+      if (column.field === field)
+        found = true;
+    if (!found)
+      return false;
+  }
+  return true;
+}
 function uniqueColumns(table, on) {
   const names = conflictNames(on);
   for (const unique of table.model.uniques) {
@@ -92,7 +128,7 @@ function uniqueColumns(table, on) {
   const accepted = table.model.uniques.map((fields) => fields.join(", "));
   throwNamed2("OKM1104", names.join(", "), accepted, `onConflict on ${table.model.name} names ${names.join(", ")}, which is not a unique constraint. Accepted: ${list(accepted)}.`);
 }
-function updateColumns(table, value) {
+function updateColumns(table, value, allow) {
   if (!Array.isArray(value) || value.length === 0) {
     fail("OKM1120", "onConflict update must name at least one column.");
   }
@@ -104,8 +140,9 @@ function updateColumns(table, value) {
     if (column === undefined) {
       throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
     }
-    if (!column.writable)
-      refuseWrite(table.model.name, column);
+    if (fieldSealed(table.model, name) || column.guardUpdate || !column.writable && !(column.guarded && allow.has(name))) {
+      refuseWrite(table, column);
+    }
     columns.push(column);
   }
   return columns;
@@ -137,10 +174,16 @@ function rejectConflictKeys(keys, accepted) {
   }
 }
 function refuseWrite(table, column) {
+  if (fieldSealed(table.model, column.field)) {
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+  }
+  if (column.guardUpdate) {
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+  }
   if (column.guarded) {
-    fail("OKM1190", `Field ${table}.${column.field} is guarded. Input cannot set it.`);
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
   }
-  fail("OKM1120", `Field ${table}.${column.field} cannot be written.`);
+  fail("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
 }
 export {
   finishInsert,

package/dist/shared/k34e0xf2.js

@@ -0,0 +1,450 @@
+import {
+  archiveRules,
+  readOptionNames,
+  readNeedsOperatorSql,
+  bindCall,
+  compileCall,
+  decodeResult,
+  logicalIntent,
+  appliedRules
+} from "./xrfnq5k8.js";
+import {
+  OkmError2,
+  safe2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/client.ts
+var PLAN_LIMIT = 64;
+var SINGLE_ENDPOINT = {
+  endpoint: "primary",
+  role: "primary",
+  reason: "single-endpoint"
+};
+function createClient(schema, pool, options) {
+  const connected = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
+    ...options.catalog !== undefined ? { catalog: options.catalog } : {},
+    ...options.catalogDir !== undefined ? { catalogDir: options.catalogDir } : {}
+  });
+  const session = {
+    schema,
+    pool,
+    ownsPool: options.ownsPool,
+    http: options.http,
+    includeValues: options.includeValues === true,
+    logger: options.logger,
+    connected,
+    cache: new Map,
+    generators: options.generators,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    closing: { current: undefined }
+  };
+  return openClient(session);
+}
+function openClient(session) {
+  const names = Object.keys(session.schema.model);
+  const tables = {};
+  for (const name of names)
+    tables[name] = tableApi(session, name);
+  const close = () => {
+    if (!session.ownsPool)
+      return Promise.resolve();
+    session.closing.current ??= session.pool.close();
+    return session.closing.current;
+  };
+  const client = {
+    ...tables,
+    table(name) {
+      const found = tables[name];
+      if (found !== undefined)
+        return found;
+      try {
+        if (session.schema.model[name] !== undefined && session.schema.tenancy !== undefined && session.scope === undefined) {
+          session.schema.tenancy.missing(name);
+        }
+        throwNamed2("OKM1120", name, names, `Table ${name} is not in the schema. Accepted names: ${names.join(", ")}.`);
+      } catch (error) {
+        if (error instanceof OkmError2)
+          throw attachHttp(session.http, error);
+        throw error;
+      }
+    },
+    close,
+    connected: session.connected,
+    tx: (...args) => import("./m78s7898.js").then((mod) => mod.tx(session, args)),
+    batch: (ops, options) => batchHandle(session, ops, options),
+    ...session.tx?.extras
+  };
+  const hooks = session.schema.hooks;
+  if (hooks !== undefined) {
+    for (const hook of hooks) {
+      hook(client, {
+        names,
+        tables,
+        scoped: session.scope !== undefined,
+        open: (scope) => openClient({ ...session, scope })
+      });
+    }
+  }
+  attachAsyncDispose(client, close);
+  return client;
+}
+function attachAsyncDispose(client, close) {
+  const symbol = Symbol.asyncDispose;
+  if (typeof symbol !== "symbol")
+    return;
+  Object.defineProperty(client, symbol, {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: () => close()
+  });
+}
+function tableApi(session, table, view, uses) {
+  const base = { uses };
+  const mods = { archive: view, uses };
+  const api = {
+    find(options = {}) {
+      if ("lock" in options) {
+        return lazyRead(session, () => import("./ydaz1sv3.js"), table, options, base, view);
+      }
+      return start(session, "find", table, options, base, view);
+    },
+    one(options = {}) {
+      return start(session, "one", table, options, base, view);
+    },
+    count(options = {}) {
+      return start(session, "count", table, options, base, view);
+    },
+    exists(options = {}) {
+      return start(session, "exists", table, options, base, view);
+    },
+    page(options) {
+      return lazyRead(session, () => import("./p24x2334.js"), table, options, base, view);
+    },
+    aggregate(options = {}) {
+      return lazyRead(session, () => import("./3ekj9x92.js"), table, options, base, view);
+    },
+    insert(data, options = {}) {
+      return writeHandle(session, "insert", table, data, options, mods);
+    },
+    update(target, options = {}) {
+      return writeHandle(session, "update", table, target, options, mods);
+    },
+    delete(target, options = {}) {
+      return writeHandle(session, "delete", table, target, options, mods);
+    }
+  };
+  const hooks = session.schema.hooks;
+  if (hooks !== undefined) {
+    for (const hook of hooks) {
+      hook(api, {
+        table,
+        ...view !== undefined ? { view } : {},
+        uses,
+        reopen: (next) => tableApi(session, table, next, uses),
+        session
+      });
+    }
+  }
+  for (const name in session.schema.model[table]?.presets) {
+    api[name] = (...args) => tableApi(session, table, view, [uses, name, args]);
+  }
+  return api;
+}
+function batchHandle(session, ops, options, replica) {
+  return queryHandle(() => import("./mt5wswjz.js").then((mod) => mod.batch(session, ops, options, replica)), {
+    replica: () => batchHandle(session, ops, options, true)
+  });
+}
+var writers;
+function loadWrite() {
+  writers ??= import("./xva8v7qk.js");
+  return writers;
+}
+function queryHandle(run, extra) {
+  let pending;
+  const once = () => {
+    pending ??= run();
+    return pending;
+  };
+  const self = {
+    then(onFulfilled, onRejected) {
+      return once().then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return self.then(undefined, onRejected);
+    },
+    finally(fn) {
+      return self.then((value) => {
+        fn();
+        return value;
+      }, (error) => {
+        fn();
+        throw error;
+      });
+    },
+    safe() {
+      return safe2(once());
+    },
+    ...extra
+  };
+  return self;
+}
+function writeHandle(session, op, table, input, options, mods) {
+  return queryHandle(() => runWrite(session, op, table, input, options, mods), {
+    "~plan": () => runWrite(session, op, table, input, options, mods, true),
+    sql() {
+      return loadWrite().then((mod) => mod.explainWrite(session.schema, op, table, input, options, mods, session.generators, session.scope));
+    },
+    expect(count) {
+      return writeHandle(session, op, table, input, options, { ...mods, expect: count });
+    },
+    all(reason) {
+      return writeHandle(session, op, table, input, options, { ...mods, all: reason });
+    }
+  });
+}
+async function runWrite(session, op, table, input, options, mods, plan) {
+  await session.connected;
+  const mod = await loadWrite();
+  try {
+    return await mod.executeWrite(session, op, table, input, options, mods, session.scope, plan);
+  } catch (error) {
+    throw logged(session, await mapError(session, error));
+  }
+}
+function start(session, op, table, options, mods, view) {
+  const model = session.schema.model[table];
+  const call = readCall(op, table, options, mods.all, session.scope, model, session.schema, view);
+  return readHandle(session, table, call, mods, async (plan, rows) => {
+    const value = await decodeRows(plan, rows, table);
+    if (mods.required === true && value === null) {
+      throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
+    }
+    return value;
+  }, (prepare) => ({
+    all(reason) {
+      return start(session, op, table, options, { ...mods, all: reason }, view);
+    },
+    required() {
+      return start(session, op, table, options, { ...mods, required: true }, view);
+    },
+    stream() {
+      return streamLazy(session, call, prepare);
+    }
+  }));
+}
+function lazyRead(session, load, table, options, mods, view) {
+  const read = () => load().then((mod) => ({ it: mod.build(session, table, options, mods, view) }));
+  return queryHandle(() => read().then((box) => box.it), {
+    inspect: () => read().then((box) => box.it.inspect()),
+    sql: () => read().then((box) => box.it.sql()),
+    all: (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view)
+  });
+}
+async function decodeRows(plan, rows, table) {
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./edwqqryd.js")).decodeIncluded(plan, rows, table);
+}
+function readHandle(session, table, call, mods, decode, extra) {
+  let prepared;
+  const origin = call;
+  const prepare = async () => {
+    if (prepared !== undefined)
+      return prepared;
+    if (mods.uses !== undefined) {
+      call = (await import("./r6nwkxnt.js")).refine(session.schema, origin, mods.uses);
+    }
+    if (readNeedsOperatorSql(session.schema, call))
+      await loadOperatorSql();
+    const hooks = await hooksFor(call);
+    const bound = bindCall(session.schema, call, hooks);
+    let plan = session.cache.get(bound.key);
+    if (plan === undefined) {
+      plan = compileCall(session.schema, call, bound.key, hooks);
+      if (session.cache.size >= PLAN_LIMIT) {
+        const oldest = session.cache.keys().next().value;
+        if (oldest !== undefined)
+          session.cache.delete(oldest);
+      }
+      session.cache.set(bound.key, plan);
+    }
+    prepared = { plan, params: bound.params };
+    return prepared;
+  };
+  const sync = () => call.include === undefined && mods.uses === undefined && !readNeedsOperatorSql(session.schema, call);
+  const run = async () => {
+    await session.connected;
+    const { plan, params } = await prepare();
+    try {
+      const result = await session.pool.execute(plan.text, params, callOptions(call, session.timeouts?.statement));
+      if (session.hookm && result.notices.length) {
+        import("./96ps4g1z.js").then((mod) => mod.notices(session.hookm, result.notices));
+      }
+      return await decode(plan, result.rows);
+    } catch (error) {
+      const mapped = await mapError(session, error);
+      if (session.schema.model[table]?.conceal !== true)
+        throw logged(session, mapped);
+      const { scrubCall } = await import("./e6wg00wd.js");
+      throw logged(session, scrubCall(mapped, session.schema, call));
+    }
+  };
+  return queryHandle(run, {
+    inspect() {
+      const source = session.schema.model[table]?.source;
+      if (call.include === undefined && prepared !== undefined) {
+        return finish(session, inspection(prepared.plan, prepared.params, call, source), call);
+      }
+      if (sync()) {
+        const bound = bindNow(session.schema, call);
+        prepared = bound;
+        return finish(session, inspection(bound.plan, bound.params, call, source), call);
+      }
+      return prepare().then(({ plan, params }) => finish(session, inspection(plan, params, call, source), call));
+    },
+    sql() {
+      if (call.include === undefined && prepared !== undefined) {
+        return { text: prepared.plan.text, params: prepared.params };
+      }
+      if (sync()) {
+        const { plan, params } = bindNow(session.schema, call);
+        prepared = { plan, params };
+        return { text: plan.text, params };
+      }
+      return prepare().then(({ plan, params }) => ({ text: plan.text, params }));
+    },
+    ...extra?.(prepare)
+  });
+}
+function streamLazy(session, call, prepare) {
+  return async function* () {
+    const { streamRows } = await import("./bryqk9k9.js");
+    yield* streamRows(session, call, prepare, (error) => logged(session, error));
+  }();
+}
+function archiveRecord(model, view) {
+  if (model?.archive === undefined)
+    return;
+  const rules = archiveRules(model, view);
+  if (rules === undefined)
+    return;
+  return { ruleLines: rules };
+}
+function readCall(op, table, options, all, scope, model, schema, view) {
+  const record = options;
+  const accepted = readOptionNames(op);
+  for (const key of Object.keys(record)) {
+    if (!accepted.includes(key)) {
+      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${op}. Accepted options: ${accepted.join(", ")}.`);
+    }
+  }
+  return {
+    op,
+    table,
+    ...record.where !== undefined ? { where: record.where } : {},
+    ...record.select !== undefined ? { select: record.select } : {},
+    ...record.orderBy !== undefined ? { orderBy: record.orderBy } : {},
+    ...record.limit !== undefined ? { limit: record.limit } : {},
+    ...record.include !== undefined ? { include: record.include } : {},
+    ...callOptions(record),
+    ...all !== undefined ? { all } : {},
+    ...scope !== undefined ? { scope } : {},
+    ...schema.tenancy !== undefined && model !== undefined ? { tenancyRules: schema.tenancy.rules(table, model.source, scope) } : {},
+    ...view !== undefined ? { archive: view } : {},
+    ...archiveRecord(model, view)
+  };
+}
+async function checkServer(pool, schema, http, requireMeta, options, source) {
+  const server = await import("./ty3v3hfk.js");
+  let rows;
+  try {
+    const result = await pool.execute(server.versionQuery, undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./s6gqfn5j.js");
+    throw mapPostgresError(error, mapOptions(http, false));
+  }
+  await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
+}
+async function mapError(session, error) {
+  if (error instanceof OkmError2) {
+    return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
+  }
+  const { mapPostgresError } = await import("./s6gqfn5j.js");
+  return mapPostgresError(error, mapOptions(session.http, session.includeValues));
+}
+function errorFields(error) {
+  return {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    fix: error.fix
+  };
+}
+var includeHooks;
+var operatorSql;
+function loadOperatorSql() {
+  operatorSql ??= import("./axhk06q1.js").then(() => {
+    return;
+  });
+  return operatorSql;
+}
+function hooksFor(call) {
+  if (call.include === undefined)
+    return Promise.resolve(undefined);
+  includeHooks ??= import("./edwqqryd.js").then((mod) => mod.includeHooks);
+  return includeHooks;
+}
+function bindNow(schema, call) {
+  const bound = bindCall(schema, call);
+  const plan = compileCall(schema, call, bound.key);
+  return { plan, params: bound.params };
+}
+function finish(session, view, call) {
+  if (session.schema.model[call.table]?.conceal !== true)
+    return view;
+  return import("./e6wg00wd.js").then((mod) => mod.redactView(session.schema, view, call));
+}
+function inspection(plan, params, call, source) {
+  return {
+    intent: logicalIntent(call),
+    rules: appliedRules(call, source),
+    plan: { strategy: "postgres:single-statement", statements: 1, fingerprint: plan.fingerprint },
+    sql: { text: plan.text, params },
+    routing: SINGLE_ENDPOINT
+  };
+}
+function withHttp(http, options) {
+  return http === undefined ? options : { ...options, http };
+}
+function attachHttp(http, error) {
+  if (http === undefined)
+    return error;
+  return new OkmError2(error.code, error.message, { ...errorFields(error), http });
+}
+function callOptions(input, statement) {
+  const timeout = input.timeout ?? statement;
+  if (input.signal === undefined && timeout === undefined)
+    return;
+  return {
+    ...input.signal !== undefined ? { signal: input.signal } : {},
+    ...timeout !== undefined ? { timeout } : {}
+  };
+}
+function mapOptions(http, includeValues) {
+  return {
+    ...http !== undefined ? { http } : {},
+    ...includeValues ? { includeValues: true } : {}
+  };
+}
+async function settleCall(session, error) {
+  throw logged(session, await mapError(session, error));
+}
+function logged(session, error) {
+  session.logger?.error?.({ code: error.code, summary: error.summary });
+  return error;
+}
+
+export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, settleCall };

package/dist/shared/k3ted12y.js

@@ -0,0 +1,33 @@
+// src/adapters/pg/watch.ts
+function openWatch(options) {
+  let kind;
+  const controller = new AbortController;
+  const onAbort = () => {
+    if (kind === undefined)
+      kind = "cancelled";
+    controller.abort();
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  let timer;
+  if (options.timeout !== undefined) {
+    timer = setTimeout(() => {
+      if (kind === undefined)
+        kind = "timeout";
+      controller.abort();
+    }, options.timeout);
+  }
+  return {
+    signal: controller.signal,
+    finish() {
+      if (timer !== undefined)
+        clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+    },
+    reason() {
+      return kind;
+    }
+  };
+}
+export {
+  openWatch
+};

package/dist/shared/k7dwkhvq.js

@@ -0,0 +1,31 @@
+// src/contracts/location.ts
+function callerLocation(skip) {
+  const lines = new Error().stack?.split(`
+`);
+  if (lines === undefined)
+    return;
+  let left = skip;
+  for (const line of lines) {
+    const slash = line.lastIndexOf("/");
+    if (slash < 0)
+      continue;
+    const tail = line.slice(slash + 1);
+    const colon = tail.indexOf(":");
+    if (colon < 1 || tail.startsWith("location."))
+      continue;
+    if (left > 0) {
+      left -= 1;
+      continue;
+    }
+    const end = tail.indexOf(":", colon + 1);
+    if (end < 0)
+      return;
+    return `${tail.slice(0, colon)}:${tail.slice(colon + 1, end)}`;
+  }
+  return;
+}
+function withLocation(message, source) {
+  return source === undefined ? message : `${message} (${source})`;
+}
+
+export { callerLocation, withLocation };

package/dist/shared/{8b04d28c.js → kgnc8grt.js}

@@ -1,11 +1,11 @@
 import {
   open3
-} from "./fgqgsb5z.js";
+} from "./75xkjv0t.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./xy79j5hq.js";
+} from "./rrstp3kb.js";
 export {
   PGLITE_CAPABILITIES as capabilities,
   hasCapability2 as hasCapability,

package/dist/shared/{hd293j9g.js → kyxb62mc.js}

@@ -1,6 +1,6 @@
 import {
   OkmError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/adapters/error.ts
 class DriverError2 extends Error {
@@ -57,6 +57,18 @@ function errorField2(error, key) {
   const value = Reflect.get(error, key);
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+function sqlstateOf(error) {
+  const code = errorField2(error, "code");
+  if (isSqlstate(code))
+    return code;
+  const errno = errorField2(error, "errno");
+  if (isSqlstate(errno))
+    return errno;
+  return errorField2(error, "sqlstate");
+}
+function isSqlstate(value) {
+  return value !== undefined && /^[0-9A-Z]{5}$/.test(value);
+}
 function mapDriverError2(error, batchIndex) {
   if (error instanceof OkmError2)
     return error;
@@ -65,7 +77,7 @@ function mapDriverError2(error, batchIndex) {
   }
   const message = error instanceof Error ? error.message : "driver error";
   return new DriverError2(message, driverFields({
-    sqlstate: errorField2(error, "code") ?? errorField2(error, "sqlstate"),
+    sqlstate: sqlstateOf(error),
     constraint: errorField2(error, "constraint_name") ?? errorField2(error, "constraint"),
     table: errorField2(error, "table_name") ?? errorField2(error, "table"),
     column: errorField2(error, "column_name") ?? errorField2(error, "column"),