okmodel 0.6.0 → 0.8.0

package/dist/shared/xfhe73sb.js

@@ -0,0 +1,436 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  withRowFilters,
+  emitWhere,
+  indexes,
+  quote,
+  isRecord,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/sort.ts
+function insertAtEnd(table, columns, rows, group, tenantFields) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFields);
+  const planned = [];
+  const countOf = new Map;
+  const firstOf = new Map;
+  for (const row of rows) {
+    if (groupColumn !== undefined && !Object.hasOwn(row, groupColumn.field)) {
+      fail2("OKM1121", `insert on ${table.model.name} needs ${groupColumn.field} so position has a group.`, "Pass the group on the row. Position is assigned for you.");
+    }
+    const key = lockText(table.model.sql, wires(tenants, row), groupColumn === undefined ? null : cellWire(groupColumn, row[groupColumn.field]));
+    if (!firstOf.has(key))
+      firstOf.set(key, row);
+    const n = (countOf.get(key) ?? 0) + 1;
+    countOf.set(key, n);
+    planned.push({ key, n, row });
+  }
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const slotOf = new Map;
+  for (const key of firstOf.keys())
+    slotOf.set(key, bind(key, "text"));
+  const baseRows = [];
+  for (const [key, row] of firstOf) {
+    const parts = [slotOf.get(key) ?? bind(key, "text")];
+    if (groupColumn !== undefined)
+      parts.push(bind(cellWire(groupColumn, row[groupColumn.field]), groupColumn.dataType));
+    for (const column of tenants)
+      parts.push(bind(cellWire(column, row[column.field]), column.dataType));
+    baseRows.push(`(${parts.join(", ")})`);
+  }
+  const baseNames = ["okm_lock"];
+  if (groupColumn !== undefined)
+    baseNames.push("okm_g");
+  for (let index = 0;index < tenants.length; index += 1)
+    baseNames.push(`okm_t${String(index)}`);
+  const lists = planned.map((item) => {
+    const slot = slotOf.get(item.key) ?? bind(item.key, "text");
+    const slots = columns.map((column) => cell(column, item.row[column.field], bind));
+    slots.push(`((select b.pos from base b where b.okm_lock = ${slot}) + ${String(item.n)})::integer`);
+    return `(${slots.join(", ")})`;
+  });
+  const insertColumns = [...columns.map((column) => quote(column.sql)), quote(position.sql)];
+  const text = [
+    "with base as (",
+    "select i.okm_lock, coalesce(max(t.",
+    quote(position.sql),
+    "), 0) as pos from (values ",
+    baseRows.join(", "),
+    ") as i(",
+    baseNames.join(", "),
+    ") left join ",
+    quote(table.model.sql),
+    " as t on ",
+    joinOn(groupColumn, tenants),
+    " group by i.okm_lock",
+    ") insert into ",
+    quote(table.model.sql),
+    " (",
+    insertColumns.join(", "),
+    ") values ",
+    lists.join(", ")
+  ].join("");
+  return { lock: groupLock([...firstOf.keys()]), text, params };
+}
+async function move(host, tableName, id, place, view) {
+  await host.connected;
+  const table = indexes(host.schema).get(tableName);
+  if (table === undefined)
+    fail2("OKM1120", `Table ${tableName} is not in the schema.`);
+  const group = groupField(table);
+  if (!sortable(table)) {
+    fail2("OKM1120", `move on ${tableName} needs sortable().`, "Add sortable() from okmodel/traits.");
+  }
+  const anchor = readPlace(place, tableName);
+  const key = moveColumn(host.schema, table);
+  if (sameId(id, anchor.id)) {
+    const current = await readOne(host, table, key, id, group, view);
+    if (current === undefined)
+      missing(tableName, id);
+    return { position: current.position };
+  }
+  const moved = await readOne(host, table, key, id, group, view);
+  if (moved === undefined)
+    missing(tableName, id);
+  const other = await readOne(host, table, key, anchor.id, group, view);
+  if (other === undefined)
+    missing(tableName, anchor.id);
+  if (moved.groupWire !== other.groupWire) {
+    const which = group ?? "group";
+    throw new OkmError2("OKM1120", `move on ${tableName} cannot place ${show(id)} ${anchor.side} ${show(anchor.id)}. ${show(anchor.id)} is in another ${which}.`, { fix: { summary: `Choose an anchor in the same ${which}.` } });
+  }
+  const statements = withRowFilters(host.scope, view, () => moveStatements(host.schema, table, key, id, anchor.id, moved, anchor.side, group));
+  const results = await runWrite(host, statements, callOptions(host));
+  const row = results[1]?.rows[0];
+  if (count(row?.[0]) !== 1)
+    missing(tableName, id);
+  if (count(row?.[1]) !== 1)
+    missing(tableName, anchor.id);
+  return { position: count(row?.[2]) };
+}
+function sortable(table) {
+  const traits = table.model.traits;
+  if (traits === undefined)
+    return false;
+  for (const trait of traits)
+    if (trait.name === "sortable")
+      return true;
+  return false;
+}
+function groupField(table) {
+  const traits = table.model.traits;
+  if (traits === undefined)
+    return;
+  for (const trait of traits) {
+    if (trait.name !== "sortable")
+      continue;
+    const group = trait.group;
+    return typeof group === "string" ? group : undefined;
+  }
+  return;
+}
+function readPlace(place, table) {
+  if (!isRecord(place))
+    fail2("OKM1120", `move on ${table} needs { before } or { after }.`);
+  const before = Object.hasOwn(place, "before");
+  const after = Object.hasOwn(place, "after");
+  if (before === after) {
+    fail2("OKM1120", `move on ${table} needs before or after, not both.`, "Pass one anchor.");
+  }
+  for (const key of Object.keys(place)) {
+    if (key === "before" || key === "after")
+      continue;
+    fail2("OKM1120", `move on ${table} does not accept ${key}. Accepted options: before, after.`);
+  }
+  return { side: before ? "before" : "after", id: before ? place.before : place.after };
+}
+function moveColumn(schema, table) {
+  const tenants = new Set(tenantFieldNames(schema.tenancy, table));
+  const fields = table.model.primary.filter((field) => !tenants.has(field));
+  if (fields.length !== 1) {
+    fail2("OKM1120", `move on ${table.model.name} needs one primary key column besides the tenant key.`);
+  }
+  return requiredColumn(table, fields[0] ?? "");
+}
+function tenantFieldNames(tenancy, table) {
+  if (tenancy === undefined)
+    return [];
+  const keys = tenancy.keys ?? [tenancy.key];
+  return keys.filter((key) => table.columns.has(key));
+}
+async function readOne(host, table, key, id, group, view) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFieldNames(host.schema.tenancy, table));
+  const statement = withRowFilters(host.scope, view, () => {
+    const parts = [];
+    const params = [];
+    parts.push("select ");
+    parts.push(quote(position.sql));
+    if (groupColumn !== undefined) {
+      parts.push(", ");
+      parts.push(quote(groupColumn.sql));
+    }
+    for (const column of tenants) {
+      parts.push(", ");
+      parts.push(quote(column.sql));
+    }
+    parts.push(" from ");
+    parts.push(quote(table.model.sql));
+    parts.push(" as t where t.");
+    parts.push(quote(key.sql));
+    parts.push(" = $1::");
+    parts.push(key.dataType);
+    params.push(key.encode(id));
+    emitWhere(host.schema, table, undefined, sink(parts, params), "t", 0, true);
+    return { text: parts.join(""), params };
+  });
+  const result = await host.pool.execute(statement.text, statement.params, callOptions(host));
+  const found = result.rows[0];
+  if (found === undefined)
+    return;
+  let at = 1;
+  const groupWire = groupColumn === undefined ? null : decodeWire(groupColumn, found[at]);
+  if (groupColumn !== undefined)
+    at += 1;
+  const tenantWires = [];
+  for (const column of tenants) {
+    tenantWires.push(decodeWire(column, found[at]));
+    at += 1;
+  }
+  return { position: count(found[0]), groupWire, tenants: tenantWires };
+}
+function moveStatements(schema, table, key, id, anchor, moved, side, group) {
+  const lock = groupLock([lockText(table.model.sql, moved.tenants, moved.groupWire)]);
+  const place = moveStatement(schema, table, key, id, anchor, moved, side, group);
+  const tenants = tenantColumns(table, tenantFieldNames(schema.tenancy, table));
+  return [lock, place, flipStatement(table, moved, group, tenants)];
+}
+function moveStatement(schema, table, key, id, anchor, moved, side, group) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFieldNames(schema.tenancy, table));
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const groupSlot = groupColumn === undefined ? "" : bind(moved.groupWire, groupColumn.dataType);
+  const tenantSlots = tenants.map((column, index) => bind(moved.tenants[index] ?? null, column.dataType));
+  const movedSlot = bind(key.encode(id), key.dataType);
+  const anchorSlot = bind(key.encode(anchor), key.dataType);
+  const delta = bind(side === "before" ? "-0.5" : "0.5", "numeric");
+  const parts = [];
+  parts.push("with members as (select t.ctid as tid, t.tableoid as toid, t.");
+  parts.push(quote(position.sql));
+  parts.push(" as pos, t.");
+  parts.push(quote(key.sql));
+  parts.push(" as ident from ");
+  parts.push(quote(table.model.sql));
+  parts.push(" as t");
+  let filtered = false;
+  if (groupColumn !== undefined) {
+    parts.push(" where t.");
+    parts.push(quote(groupColumn.sql));
+    parts.push(" is not distinct from ");
+    parts.push(groupSlot);
+    filtered = true;
+  }
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(filtered ? " and t." : " where t.");
+    parts.push(quote(column.sql));
+    parts.push(" is not distinct from ");
+    parts.push(tenantSlots[index] ?? "null");
+    filtered = true;
+  }
+  emitWhere(schema, table, undefined, sink(parts, params), "t", 0, filtered);
+  parts.push(" for update of t), numbered as (select ident, pos, tid, toid, row_number() over (order by pos, ident) as ord from members), placed as (select ident, pos, tid, toid, row_number() over (order by case when ident = ");
+  parts.push(movedSlot);
+  parts.push(" then (select ord from numbered where ident = ");
+  parts.push(anchorSlot);
+  parts.push(") + ");
+  parts.push(delta);
+  parts.push(" else ord end, case when ident = ");
+  parts.push(movedSlot);
+  parts.push(" then 0 else 1 end) as new_pos from numbered where (select count(*) from numbered where ident = ");
+  parts.push(movedSlot);
+  parts.push(") = 1 and (select count(*) from numbered where ident = ");
+  parts.push(anchorSlot);
+  parts.push(") = 1), changed as (update ");
+  parts.push(quote(table.model.sql));
+  parts.push(" as t set ");
+  parts.push(quote(position.sql));
+  parts.push(" = (-p.new_pos)::integer from placed as p where t.ctid = p.tid and t.tableoid = p.toid returning t.ctid) select (select count(*)::int from numbered where ident = ");
+  parts.push(movedSlot);
+  parts.push("), (select count(*)::int from numbered where ident = ");
+  parts.push(anchorSlot);
+  parts.push("), coalesce((select new_pos::int from placed where ident = ");
+  parts.push(movedSlot);
+  parts.push("), 0), (select count(*)::int from changed)");
+  return { text: parts.join(""), ...params.length > 0 ? { params } : {} };
+}
+function flipStatement(table, moved, group, tenants) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const parts = [
+    "update ",
+    quote(table.model.sql),
+    " as t set ",
+    quote(position.sql),
+    " = (-t.",
+    quote(position.sql),
+    ")::integer where t.",
+    quote(position.sql),
+    " < 0"
+  ];
+  if (groupColumn !== undefined) {
+    parts.push(" and t.");
+    parts.push(quote(groupColumn.sql));
+    parts.push(" is not distinct from ");
+    parts.push(bind(moved.groupWire, groupColumn.dataType));
+  }
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(" and t.");
+    parts.push(quote(column.sql));
+    parts.push(" is not distinct from ");
+    parts.push(bind(moved.tenants[index] ?? null, column.dataType));
+  }
+  return { text: parts.join(""), ...params.length > 0 ? { params } : {} };
+}
+function joinOn(group, tenants) {
+  const parts = [];
+  if (group !== undefined)
+    parts.push(`t.${quote(group.sql)} is not distinct from i.okm_g`);
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(`t.${quote(column.sql)} is not distinct from i.okm_t${String(index)}`);
+  }
+  return parts.length === 0 ? "true" : parts.join(" and ");
+}
+function lockText(sqlName, tenants, group) {
+  return JSON.stringify([sqlName, tenants, group]);
+}
+function groupLock(keys) {
+  const ordered = [...keys].sort(compareText);
+  const values = ordered.map((_, index) => `($${String(index + 1)}::text)`).join(", ");
+  return {
+    text: `select pg_advisory_xact_lock(hashtextextended(k.okm_lock, 0::bigint)) from (select v.okm_lock from (values ${values}) as v(okm_lock) order by v.okm_lock) as k`,
+    params: ordered
+  };
+}
+function compareText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function wires(columns, row) {
+  return columns.map((column) => cellWire(column, row[column.field]));
+}
+function cellWire(column, value) {
+  if (value === undefined || value === null)
+    return null;
+  return column.encode(value);
+}
+function cell(column, value, bind) {
+  if (value === undefined)
+    return "default";
+  if (value === null)
+    return bind(null, column.dataType);
+  return bind(column.encode(value), column.dataType);
+}
+function decodeWire(column, value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string") {
+    const decode = column.decode;
+    return column.encode(decode === undefined ? value : decode(value));
+  }
+  return column.encode(value);
+}
+function tenantColumns(table, fields) {
+  if (fields === undefined)
+    return [];
+  const columns = [];
+  for (const field of fields) {
+    const column = table.columns.get(field);
+    if (column !== undefined)
+      columns.push(column);
+  }
+  return columns;
+}
+function requiredColumn(table, field) {
+  const column = table.columns.get(field);
+  if (column === undefined)
+    fail2("OKM1120", `Table ${table.model.name} has no column ${field}.`);
+  return column;
+}
+function missing(table, id) {
+  throw new OkmError2("not_found", `move on ${table} could not find ${show(id)}.`, {
+    kind: "not_found",
+    table,
+    fix: { summary: "Pass the id of a row in this table." }
+  });
+}
+function show(id) {
+  if (typeof id === "string" || typeof id === "number")
+    return String(id);
+  return "that id";
+}
+function sameId(left, right) {
+  return left === right;
+}
+function count(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint")
+    return Number(value);
+  if (typeof value === "string" && value.length > 0)
+    return Number(value);
+  return 0;
+}
+function sink(parts, params) {
+  return {
+    text(value) {
+      parts.push(value);
+    },
+    param(encoded) {
+      params.push(encoded);
+      parts.push(`$${String(params.length)}`);
+    },
+    mark() {}
+  };
+}
+function callOptions(host) {
+  const limit = host.timeouts?.statement;
+  return limit === undefined ? undefined : { timeout: limit };
+}
+export {
+  insertAtEnd,
+  move
+};

package/dist/shared/{r1fdd0f6.js → z581d7ny.js}

@@ -2,17 +2,20 @@ import {
   checkout2,
   describe2,
   stream2,
+  runBatch2,
   watchReserved2,
   holdCheckout2,
   holdListener2,
   watchQuery2
-} from "./q3j1tq7a.js";
-import"./wkme6tep.js";
+} from "./wcrheftc.js";
+import"./35q0n9tz.js";
+import"./cm3w0ywp.js";
 export {
   checkout2 as checkout,
   describe2 as describe,
   holdCheckout2 as holdCheckout,
   holdListener2 as holdListener,
+  runBatch2 as runBatch,
   stream2 as stream,
   watchQuery2 as watchQuery,
   watchReserved2 as watchReserved

package/dist/shared/{8etn7d8w.js → z7s6fpxv.js}

@@ -39,7 +39,7 @@ async function refreshView(session, name, concurrently) {
       throw error;
     }
   } catch (error) {
-    const { mapPostgresError } = await import("./d5azex6s.js");
+    const { mapPostgresError } = await import("./63qtkrca.js");
     const mapped = mapPostgresError(error, {
       ...host.http !== undefined ? { http: host.http } : {},
       ...host.includeValues === true ? { includeValues: true } : {},

package/dist/shared/{32cnm7kn.js → zbqbmmrp.js}

@@ -1,21 +1,27 @@
 import {
-  noTimeout2
-} from "./8dqhth8c.js";
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  noTimeout
+} from "./q0cqt2sp.js";
 import {
   noticeBuffer,
-  WireSession,
-  cursorStream
-} from "./4az561fn.js";
+  WireSession
+} from "./mtw6jz76.js";
 import {
   BUNSQL_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/bunsql.ts
-import { SQL } from "bun";
+import { SQL as BunSQL } from "bun";
+var clientPools = new WeakSet;
+function markClientPool(pool) {
+  clientPools.add(pool);
+}
 function open5(config) {
   const max = config.max ?? 10;
   const acquireMs = config.timeouts?.acquire;
@@ -25,7 +31,9 @@ function open5(config) {
   const isClosed = () => closed;
   const named = config.prepared === "named";
   const parked = [];
-  const sql = new SQL(config.url, {
+  let dropped = 0;
+  let closures = 0;
+  const sql = new BunSQL(config.url, {
     max,
     idleTimeout: 0,
     maxLifetime: 0,
@@ -36,26 +44,53 @@ function open5(config) {
       application_name: "okmodel",
       ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
     },
-    ...config.ssl !== undefined ? { tls: config.ssl } : {}
+    ...config.ssl !== undefined ? { tls: config.ssl } : {},
+    onclose() {
+      dropped += 1;
+      closures += 1;
+    }
   });
   const root = new WireSession((text, params) => send2(sql, text, params), notices, isClosed, false, () => {
     counters.busy += 1;
   }, () => {
     counters.busy = Math.max(0, counters.busy - 1);
   });
-  const held = { sql, parked, acquireMs, counters, notices, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./j3rkk835.js").then((mod) => mod.checkout(held));
-  return {
+  const held = {
+    sql,
+    parked,
+    acquireMs,
+    counters,
+    notices,
+    isClosed,
+    closures: () => closures
+  };
+  const run = (text, params, watch) => {
+    const sent = dropped;
+    return root.query(text, params, watch).catch((error) => import("./wvdjznah.js").then((mod) => mod.recover(sql, error, text, root.depth(), clientPools.has(pool), dropped > sent, () => root.query(text, params, watch))));
+  };
+  const afterDrop = (text, params, watch) => {
+    if (dropped === 0)
+      return run(text, params, watch);
+    const seen = dropped;
+    return import("./wvdjznah.js").then((mod) => mod.drainClosed(sql).then(() => {
+      if (dropped === seen)
+        dropped = 0;
+      return run(text, params, watch);
+    }));
+  };
+  const checkout = () => closed ? rejectClosed() : import("./wvdjznah.js").then((mod) => mod.checkout(held));
+  const pool = {
     capabilities: BUNSQL_CAPABILITIES,
     execute(text, params, options) {
-      noTimeout2(options);
-      return runCall(closed, options, async (watch) => {
-        await releaseParked(parked);
-        return root.query(text, params, watch);
-      });
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return runCall(closed, options, (watch) => releaseParked(parked).then(() => afterDrop(text, params, watch)));
     },
     async batch(statements, options) {
-      noTimeout2(options);
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
       const connection = await checkout();
       try {
         return await connection.batch(statements, options);
@@ -65,10 +100,13 @@ function open5(config) {
     },
     reserve: () => checkout(),
     stream(text, params) {
-      return stream(text, params);
+      return async function* () {
+        const { streamRows } = await import("./wvdjznah.js");
+        yield* streamRows(checkout, text, params);
+      }();
     },
     listen(channel, onNotify) {
-      return listen(channel, onNotify);
+      return import("./wvdjznah.js").then((mod) => mod.listen(sql, parked, closed, channel, onNotify));
     },
     stats: () => statsOf(counters, max),
     async close() {
@@ -77,31 +115,29 @@ function open5(config) {
       await sql.close();
     }
   };
-  function stream(text, params) {
-    return async function* () {
-      const connection = await checkout();
-      try {
-        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
-      } finally {
-        await connection.release();
-      }
-    }();
-  }
-  async function listen(channel, onNotify) {
-    if (closed)
-      return rejectClosed();
-    await releaseParked(parked);
-    const subscription = await sql.listen(channel, onNotify);
-    return async () => {
-      await subscription.unlisten();
-    };
-  }
+  return pool;
 }
 function send2(sql, text, params) {
+  const refused = refuseInt8(params);
+  if (refused !== undefined)
+    return refused;
   if (params === undefined || params.length === 0)
     return sql.unsafe(text).raw();
   return sql.unsafe(text, [...params]).raw();
 }
+function refuseInt8(params) {
+  if (params === undefined)
+    return;
+  for (const value of params) {
+    if (value === null || value.length < 19 || !/^-?(?:0|[1-9]\d*)$/.test(value))
+      continue;
+    const parsed = BigInt(value);
+    if (parsed > 9223372036854775807n || parsed < -9223372036854775808n) {
+      return Promise.reject(new DriverError2("bigint out of range", { sqlstate: "22003" }));
+    }
+  }
+  return;
+}
 async function reserve(sql, acquireMs, counters) {
   counters.waiting += 1;
   try {
@@ -151,4 +187,4 @@ function statsOf(counters, size) {
   };
 }
 
-export { open5, send2, reserve, park };
+export { markClientPool, open5, send2, reserve, park };

package/dist/shared/{n7mcc1gk.js → zchaghkf.js}

@@ -18,6 +18,7 @@ var FAMILIES = {
   hasAnyKey: ["jsonb"],
   path: ["json", "jsonb"],
   matches: ["tsvector"],
+  relevance: ["tsvector"],
   "json.set": ["json", "jsonb"],
   "arr.append": ["array"],
   "arr.remove": ["array"]
@@ -53,7 +54,7 @@ var ACCEPTED = {
   jsonb: ["eq", "not", "contains", "containedBy", "hasKey", "hasAnyKey", "path", "json.set"],
   json: ["eq", "not", "path", "json.set"],
   range: ["eq", "not", "lt", "lte", "gt", "gte", "contains", "containedBy", "overlaps"],
-  tsvector: ["eq", "not", "matches"],
+  tsvector: ["eq", "not", "matches", "relevance"],
   scalar: ["eq", "not", "lt", "lte", "gt", "gte", "between", "inList", "notIn", "inc"]
 };
 var SAFE_TYPE = /^[A-Za-z_][A-Za-z0-9_]*(\(\d+\))?(\[\])*$/;
@@ -81,7 +82,7 @@ function assertOperatorFits(column, name) {
   if (families.includes(columnFamily(column.dataType)))
     return;
   const accepted = ACCEPTED[columnFamily(column.dataType)];
-  const search = name === "matches" && columnFamily(column.dataType) === "text" ? " Text search needs a tsvector column." : "";
+  const search = (name === "matches" || name === "relevance") && columnFamily(column.dataType) === "text" ? " Search needs a column built for search, not a plain text column." : "";
   throw new OkmError2("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${accepted.join(", ")}.${search}`, { fix: { summary: `Use one of: ${accepted.join(", ")}.` } });
 }
 function sqlType(dataType, column) {
@@ -110,7 +111,7 @@ function assertBoundText(value, role) {
 }
 function assertRegconfig(config) {
   if (!REGCONFIG.test(config)) {
-    throw new OkmError2("OKM1122", `Text search config ${config} must be a regconfig name such as english or pg_catalog.simple.`, { fix: { summary: "Pass a regconfig name. Quotes and extra clauses are not accepted." } });
+    throw new OkmError2("OKM1122", `Language ${config} is not a text search language. Pass a name such as english.`, { fix: { summary: "Pass a language name such as english." } });
   }
 }
 function textArray(values, role) {