@jskit-ai/resource-runtime 0.2.12 → 0.2.13

package/test/resourceRuntime.test.js

@@ -1,6 +1,5 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import knexLib from "knex";
 import { RestApiLockOutsideTransactionError, RestApiScopedQueryReadOnlyError } from "json-rest-api";
 import { defineTableResource } from "@jskit-ai/resource-core/shared/tableResource";
 import {
@@ -9,7 +8,9 @@ import {
   PageSizeError,
   RowLimitError,
   StaleRecordError,
-  UnpagedQueryError
+  SystemContextRequiredError,
+  UnpagedQueryError,
+  UnsupportedDatabaseError
 } from "../src/server/index.js";
 import { createActionCatalogue, createEntityChangedActionEvent } from "@jskit-ai/kernel/server/actions";
 import { emptyInputValidator, resolveActorId, resolveAuditActorId } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
@@ -18,7 +19,10 @@ import { normalizeOpaqueId } from "@jskit-ai/kernel/shared/support/normalize";
 import { countQueries } from "@jskit-ai/database-runtime/server/testDatabases";
 import { isLostDuplicateInsertRace } from "@jskit-ai/database-runtime/shared";
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { createTestResourceRuntime } from "../src/test/index.js";
+import { createPackageTestKnex, createTestResourceRuntime } from "../src/test/index.js";
+
+// SQLite in memory, or a PostgreSQL schema of its own on a DB_CLIENT=pg run (see createPackageTestKnex).
+const testKnex = (t) => createPackageTestKnex(t, { environment: process.env });
 
 const WORKSPACE_A = Object.freeze({ workspace: { id: "1" } });
 const WORKSPACE_B = Object.freeze({ workspace: { id: "2" } });
@@ -45,8 +49,7 @@ function noteResource(extra = {}) {
 }
 
 async function createFixture(t, { requestRowLimit, owns = [noteResource()] } = {}) {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("notes", (table) => {
     table.increments("id");
     table.integer("workspace_id").nullable();
@@ -76,6 +79,68 @@ test("a call without a context is refused before anything runs", async (t) => {
   await assert.rejects(notes.query({ page: { size: 5 } }), MissingScopeError);
 });
 
+test("a system table answers only a system context: a request's, a derived job's or none is refused before any statement", async (t) => {
+  const knex = await testKnex(t);
+  await knex.schema.createTable("leases", (table) => {
+    table.increments("id");
+    table.string("holder").notNullable();
+  });
+  const leaseResource = defineTableResource({
+    name: "leases",
+    tableName: "leases",
+    ownership: "system",
+    defaultSort: ["id"],
+    schema: { id: { type: "id", primary: true }, holder: { type: "string", required: true, search: true } }
+  });
+  const runtime = await createTestResourceRuntime({ knex });
+  const { leases } = await runtime.own("leases.feature", [leaseResource]);
+  const systemContext = runtime.declareSystemScope("leases.feature", "keep every server's leases")("take a lease");
+  const system = { context: systemContext };
+
+  // The owner's background work reads and writes every row, the many-row writes and the locks included.
+  const [first] = await leases.createMany([{ holder: "a" }, { holder: "b" }], { ...system, returning: "ids" });
+  assert.deepEqual((await leases.queryAll({}, system)).map(({ holder }) => holder), ["a", "b"]);
+  assert.equal(await leases.patchWhere({ holder: "b" }, { holder: "c" }, { ...system, returning: "count" }), 1);
+  assert.deepEqual(await leases.withTransaction(system, async (txOptions) => (await leases.claim({ filters: { holder: "a" } }, txOptions)).map(({ id }) => id)), [first]);
+
+  const statements = [];
+  knex.on("query", ({ sql }) => statements.push(sql));
+  const refused = [
+    { context: WORKSPACE_A },
+    { context: { visibilityContext: { userId: "7" } } },
+    { context: systemContext.forWorkspace("1") },
+    { context: systemContext.forUser("7", { actorId: "7" }) },
+    {}
+  ];
+  for (const options of refused) {
+    const calls = [
+      () => leases.create({ holder: "x" }, { ...options, returning: "none" }),
+      () => leases.createMany([{ holder: "x" }], options),
+      () => leases.query({ page: { size: 5 } }, options),
+      () => leases.queryAll({}, options),
+      () => leases.get(first, {}, options),
+      () => leases.aggregate({ measures: { leases: { count: "*" } } }, options),
+      () => leases.patch(first, { holder: "x" }, options),
+      () => leases.patchWhere({ holder: "a" }, { holder: "x" }, options),
+      () => leases.delete(first, options),
+      () => leases.deleteWhere({ holder: "a" }, options),
+      () => leases.scopedQuery({}, options),
+      () => leases.findOrCreate({ id: "9", holder: "x" }, options)
+    ];
+    for (const call of calls) {
+      await assert.rejects(call, (error) => error instanceof SystemContextRequiredError &&
+        error.code === "RESOURCE_SYSTEM_CONTEXT_REQUIRED" && /ownership "system"/u.test(error.message));
+    }
+  }
+  assert.deepEqual(statements, [], "a refused call sends nothing");
+  // A lock in the owner's transaction with another context is refused too.
+  await leases.withTransaction(system, async (txOptions) => {
+    await assert.rejects(leases.lock(first, { ...txOptions, context: WORKSPACE_A }), SystemContextRequiredError);
+    await assert.rejects(leases.claim({ filters: { holder: "a" } }, { ...txOptions, context: WORKSPACE_A }), SystemContextRequiredError);
+  });
+  assert.deepEqual((await knex("leases").orderBy("id")).map(({ holder }) => holder), ["a", "c"]);
+});
+
 test("reads and single writes stay in the context's workspace", async (t) => {
   const { notes, knex } = await createFixture(t);
   const mine = await notes.create({ title: "mine" }, { context: WORKSPACE_A });
@@ -181,8 +246,7 @@ test("a system context comes only from a declared system scope, one per feature,
 });
 
 test("forWorkspaceUser() reaches one user's rows in one workspace, of a workspace_user table and of a user table", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("drafts", (table) => {
     table.increments("id");
     table.integer("workspace_id").notNullable();
@@ -334,7 +398,7 @@ test("an upsert on a table with no owners may key on the id alone; an owned tabl
   );
   // On a workspace table the conflict keys must hold the owner, so json-rest-api refuses the id alone.
   await assert.rejects(notes.createMany([{ id: 1, title: "a" }], { context: WORKSPACE_A, onConflict: { keys: ["id"], action: "merge" } }));
-  assert.equal((await knex("notes").count({ count: "*" }).first()).count, 0);
+  assert.equal(Number((await knex("notes").count({ count: "*" }).first()).count), 0);
 });
 
 test("an upsert finds rows by its conflict keys alone, never by an id, and stays in the caller's workspace", async (t) => {
@@ -418,6 +482,18 @@ test("lockOrCreate() runs work on the locked record, creating it first when miss
   const bump = (record, txOptions) => resources.counters.patch(record.id, { value: record.value + 1 }, txOptions);
   assert.deepEqual(await resources.counters.lockOrCreate({ id: "visits", value: 0 }, options, bump), { id: "visits", value: 1 });
   assert.deepEqual(await resources.counters.lockOrCreate({ id: "visits", value: 0 }, options, bump), { id: "visits", value: 2 });
+  // lockMode picks the record's lock, as lock() takes it; another is refused before any transaction opens.
+  assert.deepEqual(await resources.counters.lockOrCreate({ id: "visits", value: 0 }, { ...options, lockMode: "noKeyUpdate" }, bump), { id: "visits", value: 3 });
+  assert.deepEqual(await resources.counters.lockOrCreate({ id: "fresh", value: 0 }, { ...options, lockMode: "noKeyUpdate" }, bump), { id: "fresh", value: 1 });
+  const statements = [];
+  const counted = ({ sql }) => statements.push(sql);
+  knex.on("query", counted);
+  await assert.rejects(resources.counters.lockOrCreate({ id: "moded", value: 0 }, { ...options, lockMode: "share" }, bump), {
+    name: "TypeError",
+    message: 'counters.lockOrCreate() lockMode is "update" (the default) or "noKeyUpdate". Received: "share"'
+  });
+  knex.off("query", counted);
+  assert.deepEqual(statements, []);
   // Work that fails leaves no new record behind, and runs once.
   let runs = 0;
   await assert.rejects(resources.counters.lockOrCreate({ id: "failed", value: 0 }, options, () => {
@@ -630,7 +706,7 @@ test("withTransaction() commits together and rolls back together", async (t) =>
     await notes.createMany([{ title: "b" }], txOptions);
     throw new Error("undo");
   }), /undo/u);
-  assert.equal((await knex("notes").count({ count: "*" }).first()).count, 0);
+  assert.equal(Number((await knex("notes").count({ count: "*" }).first()).count), 0);
   await notes.withTransaction({ context: WORKSPACE_A }, (txOptions) => notes.create({ title: "kept" }, txOptions));
   assert.deepEqual(await knex("notes").pluck("title"), ["kept"]);
 });
@@ -678,8 +754,7 @@ test("withTransaction() rethrows its work's own error, and takes its settings in
 });
 
 test("findOrCreate() answers the record with the id, creating it only when it is missing", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("counters", (table) => {
     table.string("counter_key").primary();
     table.integer("value").notNullable();
@@ -744,6 +819,68 @@ test("locks need a transaction and take only the caller's rows", async (t) => {
   await assert.rejects(notes.withTransaction({ context: WORKSPACE_A }, (txOptions) => notes.lock(other.id, txOptions)), notFound);
 });
 
+test("every lock and patchWhere take lockMode \"update\" or \"noKeyUpdate\" and reach the same rows; another is refused before any statement", async (t) => {
+  const { knex, notes } = await createFixture(t);
+  const [a] = await notes.createMany([{ title: "a", status: "queued" }], { context: WORKSPACE_A, returning: "ids" });
+  const statements = [];
+  const counted = ({ sql }) => statements.push(sql);
+  await notes.withTransaction({ context: WORKSPACE_A }, async (txOptions) => {
+    for (const lockMode of ["update", "noKeyUpdate"]) {
+      const options = { ...txOptions, lockMode };
+      assert.equal((await notes.lock(a, options)).title, "a", lockMode);
+      assert.deepEqual((await notes.lockMany([a], options)).map(({ title }) => title), ["a"], lockMode);
+      assert.deepEqual((await notes.lockWhere({ status: "queued" }, options)).map(({ title }) => title), ["a"], lockMode);
+      assert.deepEqual((await notes.claim({ filters: { status: "queued" } }, options)).map(({ title }) => title), ["a"], lockMode);
+      assert.equal(await notes.patchWhere({ status: "queued" }, { title: "a" }, { ...options, returning: "count" }), 1, lockMode);
+    }
+    knex.on("query", counted);
+    const options = { ...txOptions, lockMode: "share" };
+    const refused = (method) => ({ name: "TypeError", message: `notes.${method}() lockMode is "update" (the default) or "noKeyUpdate". Received: "share"` });
+    await assert.rejects(notes.lock(a, options), refused("lock"));
+    await assert.rejects(notes.lockMany([a], options), refused("lockMany"));
+    await assert.rejects(notes.lockWhere({ status: "queued" }, options), refused("lockWhere"));
+    await assert.rejects(notes.claim({ filters: { status: "queued" } }, options), refused("claim"));
+    await assert.rejects(notes.patchWhere({ status: "queued" }, { title: "b" }, options), refused("patchWhere"));
+    knex.off("query", counted);
+    // Nothing reached the database, so the transaction goes on (on PostgreSQL a failed statement would end it).
+    assert.equal((await notes.lock(a, txOptions)).title, "a");
+  });
+  assert.deepEqual(statements, []);
+});
+
+test("changeHorizon() answers PostgreSQL's snapshot horizon as decimal text; elsewhere it throws before any statement", async (t) => {
+  const { knex, notes } = await createFixture(t);
+  await assert.rejects(notes.changeHorizon({}), MissingScopeError);
+  if (knex.client.config.client === "pg") {
+    assert.match(await notes.changeHorizon({ context: WORKSPACE_A }), /^\d{1,20}$/u);
+    return;
+  }
+  const statements = [];
+  const counted = ({ sql }) => statements.push(sql);
+  knex.on("query", counted);
+  await assert.rejects(notes.changeHorizon({ context: WORKSPACE_A }), (error) => error instanceof UnsupportedDatabaseError &&
+    error.code === "RESOURCE_DATABASE_UNSUPPORTED" &&
+    error.message === "notes.changeHorizon() reads PostgreSQL's snapshot horizon (pg_snapshot_xmin), which MySQL, MariaDB and SQLite do not have.");
+  knex.off("query", counted);
+  assert.deepEqual(statements, []);
+});
+
+test("an xid8 field, PostgreSQL's transaction id, is refused where the table is on another database", async (t) => {
+  const knex = await testKnex(t);
+  if (knex.client.config.client === "pg") {
+    t.skip("PostgreSQL has xid8: changes.postgres.test.js reads it");
+    return;
+  }
+  const stamped = defineTableResource({
+    name: "stamped",
+    tableName: "stamped",
+    ownership: "public",
+    schema: { id: { type: "id", primary: true }, changed: { type: "xid8", nullable: true } }
+  });
+  const runtime = await createTestResourceRuntime({ knex });
+  await assert.rejects(runtime.own("stamped.feature", [stamped]), /Field 'changed' in resource 'stamped' has type 'xid8', PostgreSQL's transaction id, which only Knex storage on PostgreSQL has/u);
+});
+
 test("scopedQuery() answers a read-only builder over the caller's rows that orWhere cannot widen", async (t) => {
   const { notes } = await createFixture(t);
   await notes.createMany([{ title: "a" }, { title: "b" }], { context: WORKSPACE_A });
@@ -829,8 +966,7 @@ test("workspace_or_shared reads a workspace's rows and the shared ones, and writ
 });
 
 test("a context naming no owner the table needs is refused, never read as the rows with no owner", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("notes", (table) => {
     table.increments("id");
     table.integer("workspace_id").nullable();
@@ -882,9 +1018,49 @@ test("workspace_or_shared without a workspace reads only the shared rows and wri
   assert.equal((await knex("notes").where({ title: "stray" })).length, 0);
 });
 
+test("a shared row is written in the owner's system context, naming its empty owner, also inside a request's transaction", async (t) => {
+  const { notes, knex, systemContext } = await createFixture(t, { owns: [noteResource({ ownership: "workspace_or_shared" })] });
+  const forbidden = (error) => error.code === "REST_API_RESOURCE" && error.subtype === "forbidden";
+  // A job derived for a user is no system context: with no workspace to stamp, it may not create a shared row.
+  await assert.rejects(notes.create({ title: "stray" }, { context: systemContext.forUser("7") }), forbidden);
+  await assert.rejects(notes.create({ title: "stray", workspaceId: null }, { context: systemContext.forUser("7") }), forbidden);
+  // A workspace request stamps its own workspace and refuses another owner, the empty one included.
+  await assert.rejects(notes.create({ title: "stray", workspaceId: null }, { context: WORKSPACE_A }));
+  assert.equal((await knex("notes").where({ title: "stray" })).length, 0);
+  // The system context names the owner: an empty one is the shared row, and leaving it out is refused.
+  await assert.rejects(notes.create({ title: "stray" }, { context: systemContext }), /needs explicit ownership values/u);
+
+  const shared = await notes.withTransaction({ context: WORKSPACE_A }, async (txOptions) => {
+    await notes.create({ title: "mine" }, { ...txOptions, returning: "none" });
+    return notes.create({ title: "house rules", workspaceId: null }, { ...txOptions, context: systemContext });
+  });
+  assert.equal((await knex("notes").where({ id: shared.id }).first()).workspace_id, null);
+  for (const [context, titles] of [[WORKSPACE_A, ["house rules", "mine"]], [WORKSPACE_B, ["house rules"]]]) {
+    assert.deepEqual((await notes.queryAll({}, { context })).map(({ title }) => title).sort(), titles);
+  }
+  // A request or a job may not change or delete it, and its many-row writes leave shared rows out.
+  await assert.rejects(notes.patch(shared.id, { title: "taken" }, { context: WORKSPACE_A }), /only be changed in a system context/u);
+  await assert.rejects(notes.delete(shared.id, { context: systemContext.forWorkspace("1") }), /only be changed in a system context/u);
+  assert.deepEqual(await notes.patchWhere({ id: [shared.id] }, { title: "taken" }, { context: WORKSPACE_A, returning: "ids" }), []);
+
+  // The owner changes it in its system context once the request has read it in its own (it reaches the row), with
+  // the empty owner among the filters: a compare-and-set that never reaches a workspace's row, whatever id it names.
+  const { id: mine } = await notes.withTransaction({ context: WORKSPACE_A }, async (txOptions) => {
+    const reached = await notes.get(shared.id, {}, txOptions);
+    const changed = await notes.patchWhere({ id: [reached.id], workspaceId: null }, { title: "house rules, revised" }, {
+      ...txOptions, context: systemContext, returning: "ids"
+    });
+    assert.deepEqual(changed.map(String), [String(shared.id)]);
+    return (await notes.queryAll({ filters: { title: "mine" } }, txOptions))[0];
+  });
+  assert.deepEqual(await notes.patchWhere({ id: [mine], workspaceId: null }, { title: "taken" }, { context: systemContext, returning: "ids" }), []);
+  assert.equal((await knex("notes").where({ id: mine }).first()).title, "mine");
+  assert.deepEqual((await notes.deleteWhere({ id: [shared.id], workspaceId: null }, { context: systemContext, returning: "ids" })).map(String), [String(shared.id)]);
+  assert.equal(await knex("notes").where({ id: shared.id }).first(), undefined);
+});
+
 test("row policies read their own tables read-only, and contributions only narrow", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("rooms", (table) => {
     table.increments("id");
     table.string("name");
@@ -1005,9 +1181,56 @@ test("a row policy is told who the call runs for: a system context, a job it der
   assert.throws(() => systemContext.forWorkspace("1", { actorId: " " }), /forWorkspace needs the id of the user it acts for/u);
 });
 
+test("a job's actorId never moves its scope; a row policy that keys on the person holds a job done for them to their rows", async (t) => {
+  const drafts = defineTableResource({
+    name: "drafts",
+    tableName: "drafts",
+    ownership: "workspace",
+    defaultSort: ["id"],
+    schema: {
+      workspaceId: { type: "id", nullable: true, storage: { column: "workspace_id" } },
+      authorId: { type: "id", search: true, storage: { column: "author_id" } },
+      title: { type: "string", required: true }
+    }
+  });
+  const knex = await testKnex(t);
+  await knex.schema.createTable("drafts", (table) => {
+    table.increments("id");
+    table.integer("workspace_id");
+    table.integer("author_id");
+    table.string("title");
+  });
+  await knex("drafts").insert([
+    { workspace_id: 1, author_id: 9, title: "first author's" },
+    { workspace_id: 1, author_id: 8, title: "second author's" },
+    { workspace_id: 2, author_id: 9, title: "first author's elsewhere" }
+  ]);
+  const runtime = await createTestResourceRuntime({ knex });
+  const handles = await runtime.own("drafts.feature", [{
+    resource: drafts,
+    // A person sees their own drafts, whether they ask or a job asks for them; a job for no one sees its whole scope.
+    rowPolicy: ({ query, caller, column, value }) => {
+      if (caller.kind === "anonymous") return false;
+      const personId = caller.kind === "user" ? caller.userId : caller.actorId;
+      if (personId) query.where(column("authorId"), value("authorId", personId));
+      return true;
+    }
+  }]);
+  const jobs = runtime.declareSystemScope("drafts.feature", "publish drafts people scheduled")("publish a scheduled draft");
+  const titles = async (context) => (await handles.drafts.queryAll({}, { context })).map(({ title }) => title);
+
+  assert.deepEqual(await titles(jobs.forWorkspace("1")), ["first author's", "second author's"]);
+  assert.deepEqual(await titles(jobs.forWorkspace("1", { actorId: "9" })), ["first author's"]);
+  assert.deepEqual(await titles({ ...WORKSPACE_A, actor: { id: "9" } }), ["first author's"]);
+  // The person's rows in another workspace stay out: the scope comes from the workspace the job was derived for.
+  assert.deepEqual(await titles(jobs.forWorkspace("2", { actorId: "8" })), []);
+  // The policy holds the job's writes too: another person's draft is missing to it.
+  await assert.rejects(handles.drafts.patch("2", { title: "taken" }, { context: jobs.forWorkspace("1", { actorId: "9" }) }), notFound);
+  assert.equal((await knex("drafts").where({ id: 2 }).first()).title, "second author's");
+});
+
 test("an event a job publishes carries the scope of the workspace or user it works on, as a request there would", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   const runtime = await createTestResourceRuntime({ knex });
   const system = runtime.declareSystemScope("journal.feature", "announce the entries people asked for")("announce an entry");
   const published = [];
@@ -1092,9 +1315,8 @@ test("an action a system context or a job runs reads as that system context or j
   }
 });
 
-test("a report joins another owner's scopedQuery as a subquery: one statement, each owner's scope and row policy kept", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+test("a report joins another owner's joinSource() as a subquery: one statement, each owner's scope and row policy kept", async (t) => {
+  const knex = await testKnex(t);
   await knex.schema.createTable("tasks", (table) => {
     table.increments("id");
     table.integer("workspace_id");
@@ -1137,18 +1359,9 @@ test("a report joins another owner's scopedQuery as a subquery: one statement, e
       return true;
     }
   }]);
-  // Billing's owner API: its scoped invoices as a join source, with their column names. It answers the builder wrapped,
-  // since a builder is thenable and an async function would run it.
-  const billing = {
-    async invoiceSource(alias, options) {
-      const { query } = await invoices.scopedQuery({ alias }, options);
-      return { query, column: (field) => invoices.column(field, alias) };
-    }
-  };
-
   // Knex: report - open tasks and billed totals per project, joined on billing's scoped invoices
   async function projectSummary(options) {
-    const source = await billing.invoiceSource("i", options);
+    const source = await invoices.joinSource({ alias: "i" }, options);
     const billed = source.query
       .select({ projectId: source.column("projectId") })
       .sum({ billed: source.column("amount") })
@@ -1173,8 +1386,7 @@ test("a report joins another owner's scopedQuery as a subquery: one statement, e
 });
 
 test("a job done for one person records that person in audit fields and is never signed in as them", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("entries", (table) => {
     table.increments("id");
     table.integer("workspace_id");
@@ -1225,8 +1437,7 @@ test("a job done for one person records that person in audit fields and is never
 });
 
 test("a context that names no owner a linked table needs is refused there too, never shown the rows whose owner is NULL", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("profiles", (table) => {
     table.increments("id");
     table.integer("user_id");
@@ -1416,8 +1627,7 @@ test("a lockVersion patch moves the version on by one, also with no attributes,
 });
 
 test("a belongs-to field is written under its relationship, and naming both is refused", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("authors", (table) => {
     table.increments("id");
     table.string("name").notNullable();
@@ -1449,8 +1659,7 @@ test("a belongs-to field is written under its relationship, and naming both is r
 
 // Visits each belong to a workspace's customer and to a vet; customers are workspace rows, vets public ones.
 async function createVisitFixture(t) {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("customers", (table) => {
     table.increments("id");
     table.integer("workspace_id");
@@ -1505,13 +1714,12 @@ async function createVisitFixture(t) {
   // The tables each SELECT reads, in order.
   const selects = async (work) => (await countQueries(knex, work)).queries
     .filter((sql) => /^select/iu.test(sql))
-    .map((sql) => [...sql.matchAll(/from `(\w+)`/gu)].map(([, table]) => table)[0]);
-  return { visits: handles.visits, options, ids: created, selects };
+    .map((sql) => [...sql.matchAll(/from [`"](\w+)[`"]/gu)].map(([, table]) => table)[0]);
+  return { visits: handles.visits, options, ids: created, selects, postgres: knex.client.config.client === "pg" };
 }
 
 test("a read whose list filter is an empty list answers nothing without a statement, as a read that matches no row does", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("tickets", (table) => {
     table.increments("id");
     table.integer("workspace_id");
@@ -1556,8 +1764,10 @@ test("a read whose list filter is an empty list answers nothing without a statem
 });
 
 test("lock, lockMany, lockWhere and claim read only the fields they name, so a relation left out costs no visibility check", async (t) => {
-  const { visits, options, ids, selects } = await createVisitFixture(t);
+  const { visits, options, ids, selects, postgres } = await createVisitFixture(t);
   let locked;
+  // PostgreSQL's lockWhere reads once more under the locks it took, for rows that started to match while it waited.
+  const lockWhereReads = postgres ? ["visits", "visits"] : ["visits"];
   // Every field: the locking read, then one visibility check per related type.
   assert.deepEqual(await selects(() => visits.withTransaction(options, (tx) => visits.lock(ids[0], tx))), ["visits", "customers", "vets"]);
   assert.deepEqual(await selects(() => visits.withTransaction(options, async (tx) => {
@@ -1568,10 +1778,10 @@ test("lock, lockMany, lockWhere and claim read only the fields they name, so a r
     locked = await visits.lockMany(ids, { ...tx, fields: ["stage", "customerId"] });
   })), ["visits", "customers"]);
   assert.deepEqual(locked, ids.map((id) => ({ id, stage: "new", customerId: "1" })));
-  assert.deepEqual(await selects(() => visits.withTransaction(options, (tx) => visits.lockWhere({ id: ids }, tx))), ["visits", "customers", "vets"]);
+  assert.deepEqual(await selects(() => visits.withTransaction(options, (tx) => visits.lockWhere({ id: ids }, tx))), [...lockWhereReads, "customers", "vets"]);
   assert.deepEqual(await selects(() => visits.withTransaction(options, async (tx) => {
     locked = await visits.lockWhere({ id: ids }, { ...tx, fields: ["stage"] });
-  })), ["visits"]);
+  })), lockWhereReads);
   assert.deepEqual(locked, ids.map((id) => ({ id, stage: "new" })));
   assert.deepEqual(await selects(() => visits.withTransaction(options, (tx) => visits.claim({ filters: { id: ids } }, tx))), ["visits", "customers", "vets"]);
   assert.deepEqual(await selects(() => visits.withTransaction(options, async (tx) => {
@@ -1650,8 +1860,7 @@ test("a read with one include or two reads each included type once, whatever the
 });
 
 test("a record written back as it was read keeps a link to a target the writer cannot see", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("suppliers", (table) => {
     table.increments("id");
     table.string("name");
@@ -1706,8 +1915,7 @@ test("a record written back as it was read keeps a link to a target the writer c
 });
 
 test("own() refuses a cross-table filter whose target field is not indexed, whichever table is owned first", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("suppliers", (table) => {
     table.increments("id");
     table.string("name").index();
@@ -1782,8 +1990,7 @@ test("a sparse read names a belongs-to field by its own key or its relationship,
 });
 
 test("a collection relation with hydrateOnList or hydrateOnView false loads its rows only when the read includes it", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("contacts", (table) => {
     table.increments("id");
     table.string("name").notNullable();
@@ -1831,8 +2038,7 @@ test("a collection relation with hydrateOnList or hydrateOnView false loads its
 });
 
 test("an included record reads as a read of its own resource answers it, at every depth and in a collection", async (t) => {
-  const knex = knexLib({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
-  t.after(() => knex.destroy());
+  const knex = await testKnex(t);
   await knex.schema.createTable("contacts", (table) => {
     table.increments("id");
     table.string("name").notNullable();

package/test/storedIntegers.mysql.test.js

@@ -0,0 +1,4 @@
+import { storedIntegerCases } from "./support/storedIntegerCases.js";
+
+// Non-id BIGINT columns read through a handle on MariaDB/MySQL.
+storedIntegerCases("mysql");

package/test/storedIntegers.postgres.test.js

@@ -0,0 +1,5 @@
+import { storedIntegerCases } from "./support/storedIntegerCases.js";
+
+// Non-id BIGINT columns read through a handle on PostgreSQL: run with TEST_DB_NAME (and the usual DB_HOST, DB_PORT,
+// DB_USER and DB_PASSWORD) naming a PostgreSQL database, and DB_CLIENT unset or pg.
+storedIntegerCases("postgres");