okmodel 0.6.0 → 0.7.0

package/dist/shared/te5as7z7.js

@@ -0,0 +1,622 @@
+import {
+  identityColumn2
+} from "./xjk7hnn5.js";
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  queryHandle,
+  settleCall
+} from "./tbrvgw6z.js";
+import {
+  withRowFilters,
+  archiveRules,
+  emitWhere,
+  rejectKeys,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+import {
+  safetyInstalled,
+  runSafety
+} from "./a5sxz52y.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/sync.ts
+var OPTIONS = ["expect", "signal", "timeout", "route"];
+async function execute(session, table, id, relation, ids, options, mods) {
+  try {
+    const planned = await prepare(session, table, id, relation, ids, options, mods);
+    const results = await runWrite(session, [planned.lock, planned.statement], planned.call);
+    return readResult(planned, results[1]?.rows ?? []);
+  } catch (error) {
+    return settleCall(session, error);
+  }
+}
+async function explain(session, table, id, relation, ids, options, mods) {
+  try {
+    const planned = await prepare(session, table, id, relation, ids, options, mods);
+    return { statements: [planned.lock, planned.statement] };
+  } catch (error) {
+    return settleCall(session, error);
+  }
+}
+function build(session, table, input, mods, view) {
+  const packed = input;
+  const expect = mods.expect;
+  const applied = {
+    ...typeof expect === "number" ? { expect } : {},
+    archive: view,
+    uses: mods.uses
+  };
+  return queryHandle(() => execute(session, table, packed.id, packed.relation, packed.ids, packed.options, applied), {
+    sql: () => explain(session, table, packed.id, packed.relation, packed.ids, packed.options, applied)
+  });
+}
+async function prepare(session, table, id, relationName, ids, options, mods) {
+  const record = options === undefined ? {} : options;
+  if (!isRecord(record))
+    fail2("OKM1120", "sync options must be an object.");
+  rejectKeys(record, OPTIONS, "sync");
+  const owner = indexes(session.schema).get(table);
+  if (owner === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  const relation = requireRelation(owner, relationName);
+  if (relation.morph !== undefined) {
+    fail2("OKM1120", `sync does not follow ${relation.name}. Set ${relation.morph.typeField} and ${relation.morph.idField} with morphTo.`);
+  }
+  const related = indexes(session.schema).get(relation.table);
+  if (related === undefined) {
+    fail2("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+  }
+  const identity = identityColumn2(session, owner);
+  const relatedId = identityColumn2(session, related);
+  const parent = userValue(identity, id);
+  const wanted = readIds(relatedId, ids);
+  const own = String(relatedId.encode(parent));
+  if (relation.kind === "many" && relation.through === undefined && owner.model.name === related.model.name && wanted.some((item) => String(item) === own)) {
+    fail2("OKM1120", `sync on ${owner.model.name}.${relation.name} cannot make a row its own child in a tree.`, "A row cannot be its own child in a tree. Leave its id out of the list.");
+  }
+  const where = await presetWhere(session.schema, table, mods.uses);
+  noteSafety(session, table, mods.archive);
+  const statement = withRowFilters(session.scope, mods.archive, () => relation.through === undefined ? oneToMany(session, owner, related, relation, identity, relatedId, parent, wanted, where) : manyThrough(session, owner, related, relation, identity, relatedId, parent, wanted, where));
+  const lock = withRowFilters(session.scope, mods.archive, () => parentLock(session, owner, identity, parent, where));
+  return {
+    lock,
+    statement,
+    call: callOf(record),
+    expect: expectOf(mods.expect ?? record.expect),
+    decode: relatedId.decode,
+    table,
+    relation: relation.name,
+    related: related.model.name
+  };
+}
+function oneToMany(session, owner, related, relation, identity, relatedId, parent, wanted, where) {
+  const tenant = tenantSql(session, owner);
+  const clearing = [];
+  for (let index = 0;index < relation.local.length; index += 1) {
+    const parentSql = relation.local[index];
+    const childSql = relation.remote[index];
+    if (parentSql === undefined || childSql === undefined)
+      continue;
+    if (tenant.has(parentSql))
+      continue;
+    clearing.push({ child: childSql, parent: parentSql });
+  }
+  if (clearing.length === 0) {
+    fail2("OKM1120", `sync on ${owner.model.name}.${relation.name} cannot clear a link.`, "The foreign key is only the tenant key.");
+  }
+  const catalog = catalogOf(session.schema);
+  for (const link of clearing) {
+    const column = related.model.columns.find((item) => item.sql === link.child);
+    const stored = storedColumn(catalog, related.model.sql, link.child);
+    if (stored === undefined || stored.nullable !== true) {
+      fail2("OKM1120", `sync on ${owner.model.name}.${relation.name} would delete rows to drop a link. ${related.model.name}.${column?.field ?? link.child} is not nullable.`, "Use a nullable foreign key, or a join table.");
+    }
+  }
+  const sink = text();
+  sink.text("with locked as materialized (select ");
+  emitSelectLocked(sink, relation.local);
+  sink.text(" from ");
+  sink.text(quote(owner.model.sql));
+  sink.text(" p where p.");
+  sink.text(quote(identity.sql));
+  sink.text(" = ");
+  sink.param(identity.encode(parent));
+  emitWhere(session.schema, owner, where, sink, "p", 0, true);
+  sink.text(" for update), ");
+  emitDesired(sink, relatedId, wanted);
+  sink.text(", missing as (select d.id from desired d where not exists (select 1 from ");
+  sink.text(quote(related.model.sql));
+  sink.text(" r where r.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" = d.id");
+  emitWhere(session.schema, related, undefined, sink, "r", 0, true);
+  sink.text(")), guard as (select (select count(*) from locked) as parents, (select count(*) from missing) as missing_n), held as materialized (select c.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" as id from ");
+  sink.text(quote(related.model.sql));
+  sink.text(" c where (");
+  emitChildMatch(sink, "c", clearing);
+  sink.text(" or c.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" in (select d.id from desired d))");
+  emitGuard(sink);
+  emitWhere(session.schema, related, undefined, sink, "c", 0, true);
+  sink.text(" order by c.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" for update), changed as (update ");
+  sink.text(quote(related.model.sql));
+  sink.text(" c set ");
+  emitSetCase(sink, "c", relatedId, clearing);
+  sink.text(" where c.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" in (select h.id from held h) and ");
+  emitWillChange(sink, "c", relatedId, clearing);
+  emitWhere(session.schema, related, undefined, sink, "c", 0, true);
+  emitGuard(sink);
+  sink.text(" returning c.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" as id, case when c.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" in (select d.id from desired d) then 'a' else 'r' end as kind) ");
+  emitReport(sink, "kind");
+  return sink.finish();
+}
+function manyThrough(session, owner, related, relation, identity, relatedId, parent, wanted, where) {
+  const through = relation.through;
+  if (through === undefined) {
+    fail2("OKM1120", `Relation ${relation.name} has no join table.`);
+  }
+  const join = indexes(session.schema).get(through.table);
+  if (join === undefined) {
+    fail2("OKM1120", `Relation ${relation.name} names ${through.table}, which is not in the schema.`);
+  }
+  const slots = joinSlots(relation, relatedId);
+  const catalog = catalogOf(session.schema);
+  for (const column of join.model.columns) {
+    if (slots.some((slot) => slot.join === column.sql))
+      continue;
+    const stored = storedColumn(catalog, join.model.sql, column.sql);
+    if (stored !== undefined && canOmit(stored))
+      continue;
+    fail2("OKM1120", `sync on ${owner.model.name}.${relation.name} cannot fill ${join.model.name}.${column.field}.`, "A database default can fill it. sync does not.");
+  }
+  const link = slots.find((slot) => slot.from === "desired");
+  if (link === undefined) {
+    fail2("OKM1120", `sync on ${owner.model.name}.${relation.name} cannot see the related id.`);
+  }
+  const ownerSlots = slots.filter((slot) => slot.from === "locked");
+  if (ownerSlots.length === 0) {
+    fail2("OKM1120", `sync on ${owner.model.name}.${relation.name} cannot see the parent row.`);
+  }
+  const sink = text();
+  sink.text("with locked as materialized (select ");
+  emitSelectLocked(sink, relation.local);
+  sink.text(" from ");
+  sink.text(quote(owner.model.sql));
+  sink.text(" p where p.");
+  sink.text(quote(identity.sql));
+  sink.text(" = ");
+  sink.param(identity.encode(parent));
+  emitWhere(session.schema, owner, where, sink, "p", 0, true);
+  sink.text(" for update), ");
+  emitDesired(sink, relatedId, wanted);
+  sink.text(", missing as (select d.id from desired d where not exists (select 1 from ");
+  sink.text(quote(related.model.sql));
+  sink.text(" r where r.");
+  sink.text(quote(relatedId.sql));
+  sink.text(" = d.id");
+  emitWhere(session.schema, related, undefined, sink, "r", 0, true);
+  sink.text(")), guard as (select (select count(*) from locked) as parents, (select count(*) from missing) as missing_n), removed as (delete from ");
+  sink.text(quote(join.model.sql));
+  sink.text(" j where ");
+  emitJoinLocked(sink, "j", ownerSlots);
+  sink.text(" and not exists (select 1 from desired d where d.id = j.");
+  sink.text(quote(link.join));
+  sink.text(")");
+  emitWhere(session.schema, join, undefined, sink, "j", 0, true);
+  emitGuard(sink);
+  sink.text(" returning j.");
+  sink.text(quote(link.join));
+  sink.text(" as id), added as (insert into ");
+  sink.text(quote(join.model.sql));
+  sink.text(" (");
+  for (let index = 0;index < slots.length; index += 1) {
+    const slot = slots[index];
+    if (slot === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(quote(slot.join));
+  }
+  sink.text(") select ");
+  for (let index = 0;index < slots.length; index += 1) {
+    const slot = slots[index];
+    if (slot === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    if (slot.from === "desired")
+      sink.text("d.id");
+    else
+      emitLocked(sink, slot.locked ?? "");
+  }
+  sink.text(" from desired d where not exists (select 1 from ");
+  sink.text(quote(join.model.sql));
+  sink.text(" j where ");
+  emitJoinLocked(sink, "j", ownerSlots);
+  sink.text(" and j.");
+  sink.text(quote(link.join));
+  sink.text(" = d.id");
+  emitWhere(session.schema, join, undefined, sink, "j", 0, true);
+  sink.text(")");
+  emitGuard(sink);
+  sink.text(" returning ");
+  sink.text(quote(link.join));
+  sink.text(" as id) ");
+  emitReport(sink, "split");
+  return sink.finish();
+}
+function joinSlots(relation, relatedId) {
+  const through = relation.through;
+  if (through === undefined)
+    return [];
+  const slots = [];
+  const seen = new Set;
+  const add = (slot) => {
+    if (seen.has(slot.join))
+      return;
+    seen.add(slot.join);
+    slots.push(slot);
+  };
+  for (let index = 0;index < relation.remote.length; index += 1) {
+    const join = relation.remote[index];
+    const locked = relation.local[index];
+    if (join === undefined || locked === undefined)
+      continue;
+    add({ join, from: "locked", locked });
+  }
+  for (let index = 0;index < through.local.length; index += 1) {
+    const join = through.local[index];
+    const remote = through.remote[index];
+    if (join === undefined || remote === undefined)
+      continue;
+    if (remote === relatedId.sql)
+      add({ join, from: "desired" });
+    else if (relation.local.includes(remote))
+      add({ join, from: "locked", locked: remote });
+    else {
+      fail2("OKM1120", `sync cannot copy ${remote} onto the join table.`, "The join's foreign key has a column this row does not.");
+    }
+  }
+  return slots;
+}
+function parentLock(session, owner, identity, parent, where) {
+  const sink = text();
+  sink.text("select p.");
+  sink.text(quote(identity.sql));
+  sink.text(" from ");
+  sink.text(quote(owner.model.sql));
+  sink.text(" p where p.");
+  sink.text(quote(identity.sql));
+  sink.text(" = ");
+  sink.param(identity.encode(parent));
+  emitWhere(session.schema, owner, where, sink, "p", 0, true);
+  sink.text(" for update");
+  return sink.finish();
+}
+function emitSelectLocked(sink, columns) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text("p.");
+    sink.text(quote(name));
+  }
+}
+function emitDesired(sink, column, ids) {
+  sink.text("desired as (");
+  if (ids.length === 0) {
+    sink.text("select cast(null as ");
+    sink.text(column.dataType);
+    sink.text(") as id where false");
+  } else {
+    sink.text("select distinct v.id from (values ");
+    for (let index = 0;index < ids.length; index += 1) {
+      const encoded = ids[index];
+      if (encoded === undefined)
+        continue;
+      if (index > 0)
+        sink.text(", ");
+      sink.text("(cast(");
+      sink.param(encoded);
+      sink.text(" as ");
+      sink.text(column.dataType);
+      sink.text("))");
+    }
+    sink.text(") as v(id)");
+  }
+  sink.text(")");
+}
+function emitChildMatch(sink, alias, links) {
+  for (let index = 0;index < links.length; index += 1) {
+    const link = links[index];
+    if (link === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(link.child));
+    sink.text(" = ");
+    emitLocked(sink, link.parent);
+  }
+}
+function emitSetCase(sink, alias, identity, links) {
+  for (let index = 0;index < links.length; index += 1) {
+    const link = links[index];
+    if (link === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(quote(link.child));
+    sink.text(" = case when ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(identity.sql));
+    sink.text(" in (select d.id from desired d) then ");
+    emitLocked(sink, link.parent);
+    sink.text(" else null end");
+  }
+}
+function emitWillChange(sink, alias, identity, links) {
+  sink.text("((");
+  emitChildMatch(sink, alias, links);
+  sink.text(" and not exists (select 1 from desired d where d.id = ");
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(identity.sql));
+  sink.text(")) or (");
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(identity.sql));
+  sink.text(" in (select d.id from desired d) and (");
+  emitDistinct(sink, alias, links);
+  sink.text(")))");
+}
+function emitDistinct(sink, alias, links) {
+  for (let index = 0;index < links.length; index += 1) {
+    const link = links[index];
+    if (link === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" or ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(link.child));
+    sink.text(" is distinct from ");
+    emitLocked(sink, link.parent);
+  }
+}
+function emitJoinLocked(sink, alias, slots) {
+  for (let index = 0;index < slots.length; index += 1) {
+    const slot = slots[index];
+    if (slot === undefined || slot.locked === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(slot.join));
+    sink.text(" = ");
+    emitLocked(sink, slot.locked);
+  }
+}
+function emitLocked(sink, column) {
+  sink.text("(select l.");
+  sink.text(quote(column));
+  sink.text(" from locked l)");
+}
+function emitGuard(sink) {
+  sink.text(" and (select g.parents from guard g) = 1 and (select g.missing_n from guard g) = 0");
+}
+function emitReport(sink, changes) {
+  sink.text(changes === "kind" ? "select 'm'::text, d.id::text from missing d union all select ch.kind, ch.id::text from changed ch union all select 'p'::text, g.parents::text from guard g" : "select 'm'::text, d.id::text from missing d union all select 'a'::text, a.id::text from added a union all select 'r'::text, r.id::text from removed r union all select 'p'::text, g.parents::text from guard g");
+}
+function readResult(planned, rows) {
+  const added = [];
+  const removed = [];
+  let parents = 0;
+  let missing = 0;
+  for (const row of rows) {
+    const kind = row[0];
+    const value = row[1];
+    if (kind === "p")
+      parents = Number(value);
+    else if (kind === "m")
+      missing += 1;
+    else if (value === null || value === undefined)
+      continue;
+    else if (kind === "a")
+      added.push(decode(planned.decode, value));
+    else if (kind === "r")
+      removed.push(decode(planned.decode, value));
+  }
+  if (parents !== 1) {
+    throw new OkmError2("not_found", `sync on ${planned.table} did not find that id.`, {
+      kind: "not_found",
+      table: planned.table,
+      fix: { summary: "Pass an id that is in the table." }
+    });
+  }
+  if (missing > 0) {
+    throw new OkmError2("not_found", `sync on ${planned.table}.${planned.relation} is missing ${String(missing)} ids.`, {
+      kind: "not_found",
+      table: planned.table,
+      fix: { summary: `Pass ids that exist on ${planned.related}.` }
+    });
+  }
+  const changed = added.length + removed.length;
+  if (planned.expect !== undefined && changed !== planned.expect) {
+    throw new OkmError2("not_found", `sync on ${planned.table}.${planned.relation} changed ${String(changed)} links. expect was ${String(planned.expect)}.`, {
+      kind: "not_found",
+      table: planned.table,
+      fix: { summary: "Change the ids, or pass the number of links this sync changed." }
+    });
+  }
+  added.sort(byText);
+  removed.sort(byText);
+  return { added, removed };
+}
+function decode(fn, wire) {
+  return fn === undefined ? wire : fn(wire);
+}
+function byText(left, right) {
+  return String(left) < String(right) ? -1 : String(left) > String(right) ? 1 : 0;
+}
+function requireRelation(table, name) {
+  if (typeof name !== "string" || name.length === 0)
+    fail2("OKM1120", "sync relation must be a name.");
+  const relation = table.relations.get(name);
+  if (relation === undefined) {
+    throwNamed2("OKM1120", name, [...table.relations.keys()], `Relation ${name} is not on ${table.model.name}. Accepted names: ${list([...table.relations.keys()])}.`);
+  }
+  if (relation.kind !== "many") {
+    fail2("OKM1120", `sync on ${table.model.name}.${name} is not a to-many relation.`, "Pass a many or manyThrough relation.");
+  }
+  return relation;
+}
+function readIds(column, ids) {
+  if (!Array.isArray(ids))
+    fail2("OKM1120", "sync ids must be a list.");
+  const unique = [];
+  const seen = new Set;
+  for (const id of ids) {
+    if (id === undefined || id === null)
+      fail2("OKM1121", "sync ids cannot include null.");
+    const encoded = column.encode(id);
+    if (seen.has(encoded))
+      continue;
+    seen.add(encoded);
+    unique.push(encoded);
+  }
+  return unique;
+}
+function userValue(column, id) {
+  if (id === undefined || id === null)
+    fail2("OKM1121", `${column.field} needs a value.`);
+  return id;
+}
+function expectOf(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new OkmError2("invalid", "expect must be an integer from 0 up.", { kind: "invalid" });
+  }
+  return value;
+}
+function callOf(options) {
+  const signal = options.signal;
+  const timeout = options.timeout;
+  const route = options.route;
+  const hasSignal = typeof signal === "object" && signal !== null && "aborted" in signal;
+  const hasTimeout = typeof timeout === "number";
+  const hasRoute = route === "primary" || route === "replica";
+  if (!hasSignal && !hasTimeout && !hasRoute)
+    return;
+  return {
+    ...hasSignal ? { signal } : {},
+    ...hasTimeout ? { timeout } : {},
+    ...hasRoute ? { route } : {}
+  };
+}
+async function presetWhere(schema, table, uses) {
+  if (uses === undefined)
+    return;
+  const { resolve } = await import("./m7n9h2a5.js");
+  const { stack } = await import("./7n7ddwt4.js");
+  return stack(undefined, resolve(schema, table, uses).wheres);
+}
+function noteSafety(session, table, view) {
+  if (!safetyInstalled())
+    return;
+  const model = session.schema.model[table];
+  const rules = [];
+  const tenancy = session.schema.tenancy;
+  if (tenancy !== undefined) {
+    for (const rule of tenancy.rules(table, model?.source, session.scope))
+      rules.push(rule);
+  }
+  const archive = archiveRules(model, view);
+  if (archive !== undefined) {
+    for (const rule of archive)
+      rules.push(rule);
+  }
+  const scope = session.scope;
+  const hatches = scope !== undefined && "unscoped" in scope ? [{ name: "unscoped", reason: scope.unscoped }] : undefined;
+  runSafety(rules, hatches);
+}
+function tenantSql(session, table) {
+  const tenancy = session.schema.tenancy;
+  const fields = tenancy === undefined ? [] : tenancy.keys ?? [tenancy.key];
+  const sql = new Set;
+  for (const field of fields) {
+    const column = table.columns.get(field);
+    if (column !== undefined)
+      sql.add(column.sql);
+  }
+  return sql;
+}
+function catalogOf(schema) {
+  const catalog = schema.catalog;
+  if (catalog === undefined)
+    fail2("OKM1120", "sync needs the schema catalog.");
+  return catalog;
+}
+function storedColumn(catalog, tableSql, columnSql) {
+  for (const object of catalog.objects) {
+    if (object.kind !== "column")
+      continue;
+    if (object.identity.parent.name !== tableSql || object.identity.name !== columnSql)
+      continue;
+    return object.definition;
+  }
+  return;
+}
+function canOmit(definition) {
+  return definition.nullable || definition.defaultExpression !== undefined || definition.identity !== undefined || definition.generated !== undefined;
+}
+function text() {
+  const parts = [];
+  const params = [];
+  let n = 0;
+  return {
+    text(value) {
+      parts.push(value);
+    },
+    param(encoded) {
+      n += 1;
+      params.push(encoded);
+      parts.push(`$${String(n)}`);
+    },
+    mark() {},
+    finish() {
+      return { text: parts.join(""), params };
+    }
+  };
+}
+export {
+  build,
+  execute,
+  explain
+};

package/dist/shared/{ttmg09vd.js → tsvww22q.js}

@@ -5,7 +5,7 @@ import {
 } from "./qq3899ht.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   quoteIdent,
   uniqueBeforeForeignKey,

package/dist/shared/{y2t3jktd.js → ttsqgp4p.js}

@@ -1,7 +1,13 @@
+import {
+  POSTGRES_FLOOR,
+  isPostgresMajor,
+  parsePostgresFloor,
+  serverNeedsPostgres
+} from "./ga9j92qj.js";
 import {
   withHttp,
   attachHttp
-} from "./j60w0dvr.js";
+} from "./tbrvgw6z.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -11,7 +17,7 @@ var versionQuery = "select current_setting('server_version_num'), version(), (se
 async function acceptServer(pool, schema, rows, http, requireMeta, options, source) {
   for (const name in schema.model) {
     if (schema.model[name]?.presets !== undefined) {
-      (await import("./r6nwkxnt.js")).checkSchema(schema);
+      (await import("./m7n9h2a5.js")).checkSchema(schema);
       break;
     }
   }
@@ -41,20 +47,21 @@ async function acceptServer(pool, schema, rows, http, requireMeta, options, sour
     }
   }
   const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
-  const requires = schema.requires?.postgres;
-  if (requires === undefined) {
-    if (major < 15) {
-      throw new OkmError2("OKM1803", `The server is PostgreSQL ${String(major)}. PostgreSQL 15 is the oldest supported.`, withHttp(http, {
-        fix: { summary: "Upgrade to PostgreSQL 15, or set schema({ requires }) to this major." }
+  const raw = schema.requires?.postgres;
+  if (raw === undefined) {
+    if (major < POSTGRES_FLOOR) {
+      throw new OkmError2("OKM1803", serverNeedsPostgres(major, POSTGRES_FLOOR), withHttp(http, {
+        fix: {
+          summary: `Upgrade to PostgreSQL ${String(POSTGRES_FLOOR)} or higher.`
+        }
       }));
     }
     return;
   }
-  const match = /^>=(\d+)$/.exec(requires.trim());
-  const need = match?.[1] === undefined ? undefined : Number(match[1]);
-  if (need === undefined || major < need) {
-    throw new OkmError2("OKM1802", `The server is PostgreSQL ${String(major)}. schema({ requires }) asks for ${requires}.`, withHttp(http, {
-      fix: { summary: "Upgrade the server, or lower requires to a version the server meets." }
+  const need = parsePostgresFloor(raw);
+  if (!isPostgresMajor(need) || major < need) {
+    throw new OkmError2("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
     }));
   }
 }

package/dist/shared/{x72jb7ad.js → v8g1vgv8.js}

@@ -6,7 +6,7 @@ import {
   acquireTimeout2,
   errorField2,
   mapDriverError2
-} from "./31vm914h.js";
+} from "./cm3w0ywp.js";
 export {
   DriverError2 as DriverError,
   acquireTimeout2 as acquireTimeout,