kern-orm 0.3.0 → 0.5.0

package/dist/testing.d.mts

@@ -1,2 +1,28 @@
-import { A as TestFixture, M as TestHooks, N as TestTransactionOptions, O as OpenedTestFixture, P as createTestHelpers, j as TestHelpers, k as PendingTestFixture } from "./index-CNqYlONX.mjs";
-export { type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };
+import { Fr as Driver, G as TestHooks, H as PendingTestFixture, K as TestTransactionOptions, U as TestFixture, V as OpenedTestFixture, W as TestHelpers, q as createTestHelpers } from "./index-Cag6_erK.mjs";
+/** Options of `describeDriverContract`: how to create the driver under test. */
+interface DriverContractOptions {
+  /** Creates a driver over a new client of the test database with `max` connections. */
+  createDriver(options: {
+    max: number;
+  }): Driver;
+  /** Creates a driver over a new client of the test database whose parsers of result values throw; for a client without parsers, the same as `createDriver`. */
+  createDriverWithFailingParsers(): Driver;
+  /** Whether the client can close a reserved connection, so that the driver gets rid of a connection left in a transaction or lost; `false` leaves out the tests of it. */
+  closesReservedConnections: boolean;
+}
+/**
+ * Functions of a test runner that declare the tests of `describeDriverContract`.
+ *
+ * They are `describe`, `it`, `before`, and `after` of `node:test`, and `describe`, `it`, `beforeAll`, and `afterAll` of `bun:test` and Vitest.
+ */
+interface DriverContractRunner extends TestHooks {
+  describe(name: string, body: () => void): unknown;
+  it(name: string, test: () => Promise<void>): unknown;
+}
+/**
+ * Declares the tests of the contract of `Driver` for a driver.
+ *
+ * They run in the empty database of its clients and leave it unchanged.
+ */
+export declare function describeDriverContract(options: DriverContractOptions, runner: DriverContractRunner): void;
+export { type DriverContractOptions, type DriverContractRunner, type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };

package/dist/testing.mjs

@@ -1,3 +1,7 @@
+import { n as text, t as char } from "./text-BTFErHIi.mjs";
+import { a as defineSchema, g as defineTable, i as sql, m as createStatement, r as param, t as createDatabase, x as and } from "./database-BJ0hNYrF.mjs";
+import { _ as timestamptz, a as numeric, b as array, d as jsonb, f as enumOf, g as timestamp, h as time, i as integer, l as inet, m as interval, n as bigint, p as date, r as doublePrecision, t as uuid, v as boolean, y as bytea } from "./types-D9LtZ9W-.mjs";
+import assert from "node:assert/strict";
 // src/execution/testing.ts
 /** Creates the test helpers of a database created with `test: true`, registering fixtures with the hooks of a test runner. */
 function createTestHelpers(database, hooks) {
@@ -31,4 +35,520 @@ function createTestHelpers(database, hooks) {
 		}
 	};
 }
-export { createTestHelpers };
+// src/execution/driver-contract.ts
+/** Creates helpers that run raw statements on `database`. */
+function createStatementRunners(database) {
+	return {
+		async runStatement(text) {
+			await database.execute(createStatement(text));
+		},
+		async selectValue(text, parameters = []) {
+			const { rows } = await database.execute(createStatement(text, parameters));
+			return rows[0][0];
+		}
+	};
+}
+/**
+* Declares the tests of the contract of `Driver` for a driver.
+*
+* They run in the empty database of its clients and leave it unchanged.
+*/
+function describeDriverContract(options, runner) {
+	const { createDriver, createDriverWithFailingParsers, closesReservedConnections } = options;
+	const { describe, it, before, after } = runner;
+	describe("driver contract", () => {
+		const database = createDatabase({ driver: createDriver({ max: 2 }) });
+		after(() => database.close());
+		const { runStatement, selectValue } = createStatementRunners(database);
+		it("executes a query in a transaction", async () => {
+			const tag = defineTable("pg_tag_test", {
+				id: integer,
+				label: text
+			});
+			const db = database.bind(defineSchema({ tag }));
+			const rows = await database.transaction(async () => {
+				await runStatement("CREATE TEMP TABLE pg_tag_test (id integer, label text) ON COMMIT DROP");
+				await runStatement("INSERT INTO pg_tag_test VALUES (1, 'first'), (2, 'second')");
+				return await db.tag.select("label").where({ id: 2 });
+			});
+			assert.deepEqual(rows, [{ label: "second" }]);
+		});
+		it("executes a script of several statements on the connection of a transaction", async () => {
+			const labels = await database.transaction(async () => {
+				await database.script(`
+        CREATE TEMP TABLE pg_script_test (label text) ON COMMIT DROP;
+        INSERT INTO pg_script_test VALUES ('first'), ('second');
+      `);
+				return await selectValue("SELECT string_agg(label, ',' ORDER BY label) FROM pg_script_test");
+			});
+			assert.equal(labels, "first,second");
+		});
+		it("rejects a text of several statements without parameters before running any", async () => {
+			try {
+				await assert.rejects(database.execute(createStatement("CREATE TABLE pg_statement_test (id integer); SELECT 1")), /cannot insert multiple commands into a prepared statement/);
+				assert.equal(await selectValue("SELECT to_regclass('pg_statement_test')::text"), null);
+			} finally {
+				await database.script("SET LOCAL client_min_messages = warning; DROP TABLE IF EXISTS pg_statement_test");
+			}
+		});
+		it("keeps the values of a statement as text without the parsers of the client", async () => {
+			const parsed = createDatabase({ driver: createDriverWithFailingParsers() });
+			try {
+				const { rows } = await parsed.execute(createStatement("SELECT 1"));
+				assert.deepEqual(rows, [["1"]]);
+			} finally {
+				await parsed.close();
+			}
+		});
+		it("executes a script without the parsers of the client", async () => {
+			const parsed = createDatabase({ driver: createDriverWithFailingParsers() });
+			try {
+				await parsed.script("SELECT 1; SELECT 2");
+			} finally {
+				await parsed.close();
+			}
+		});
+		it("executes a script on the pool in one implicit transaction", async () => {
+			try {
+				await assert.rejects(database.script("CREATE TABLE pg_script_pool_test (id integer); SELECT 1/0"), /division by zero/);
+				assert.equal(await selectValue("SELECT to_regclass('pg_script_pool_test')::text"), null);
+			} finally {
+				await database.script("SET LOCAL client_min_messages = warning; DROP TABLE IF EXISTS pg_script_pool_test");
+			}
+		});
+		it("reports the number of rows of the command tag", async () => {
+			const counts = await database.transaction(async () => {
+				const created = await database.execute(createStatement("CREATE TEMP TABLE pg_count_test (id integer) ON COMMIT DROP"));
+				const inserted = await database.execute(createStatement("INSERT INTO pg_count_test VALUES (1), (2), (3)"));
+				const updated = await database.execute(createStatement("UPDATE pg_count_test SET id = id + 1 WHERE id > 1"));
+				return [
+					created.count,
+					inserted.count,
+					updated.count
+				];
+			});
+			assert.deepEqual(counts, [
+				0,
+				3,
+				2
+			]);
+		});
+		it("reports the names of the result columns, also without rows", async () => {
+			const { created, selected } = await database.transaction(async () => ({
+				created: await database.execute(createStatement("CREATE TEMP TABLE pg_columns_test (id integer, label text) ON COMMIT DROP")),
+				selected: await database.execute(createStatement("SELECT id, label FROM pg_columns_test"))
+			}));
+			assert.deepEqual(created.columns, []);
+			assert.deepEqual(selected.columns, ["id", "label"]);
+			assert.deepEqual(selected.rows, []);
+		});
+		it("infers the types of parameters from the statement", async () => {
+			assert.equal(await selectValue("SELECT $1::integer + $2", ["1", "2"]), "3");
+			assert.equal(await selectValue("SELECT $1", ["text"]), "text");
+			assert.equal(await selectValue("SELECT $1::text IS NULL", [null]), "t");
+		});
+		it("runs concurrent statements of a transaction in the order of calls", async () => {
+			const values = await database.transaction(() => Promise.all([
+				selectValue("SELECT set_config('kern.test', '1', true) FROM pg_sleep(0.05)"),
+				selectValue("SELECT current_setting('kern.test')"),
+				selectValue("SELECT set_config('kern.test', '2', true)"),
+				selectValue("SELECT current_setting('kern.test')")
+			]));
+			assert.deepEqual(values, [
+				"1",
+				"1",
+				"2",
+				"2"
+			]);
+		});
+		it("decodes selected expressions with their types", async () => {
+			const tag = defineTable("pg_tag_test", {
+				id: integer,
+				label: text.nullable()
+			});
+			const db = database.bind(defineSchema({ tag }));
+			const rows = await database.transaction(async () => {
+				await runStatement("CREATE TEMP TABLE pg_tag_test (id integer, label text) ON COMMIT DROP");
+				await runStatement("INSERT INTO pg_tag_test VALUES (1, 'first'), (2, NULL)");
+				return await db.tag.select((columns) => ({
+					key: columns.id,
+					name: columns.label,
+					isFirst: columns.label.eq("first"),
+					total: sql(bigint)`count(*) OVER ()`,
+					length: sql(integer.nullable())`length(${columns.label})`
+				}));
+			});
+			assert.deepEqual(rows.toSorted((a, b) => a.key - b.key), [{
+				key: 1,
+				name: "first",
+				isFirst: true,
+				total: 2n,
+				length: 5
+			}, {
+				key: 2,
+				name: null,
+				isFirst: null,
+				total: 2n,
+				length: null
+			}]);
+		});
+		it("rejects a transaction whose failed statement the callback caught", async () => {
+			const transaction = database.transaction(async () => {
+				await runStatement("SELECT 1/0").catch(() => {});
+				return "done";
+			});
+			await assert.rejects(transaction, /Transaction was rolled back/);
+		});
+		it("releases a clean connection after a failed commit", async () => {
+			const single = createDatabase({ driver: createDriver({ max: 1 }) });
+			try {
+				const transaction = single.transaction(async () => {
+					await single.execute(createStatement("CREATE TEMP TABLE pg_commit_test (id integer UNIQUE DEFERRABLE INITIALLY DEFERRED) ON COMMIT DROP"));
+					await single.execute(createStatement("INSERT INTO pg_commit_test VALUES (1), (1)"));
+				});
+				await assert.rejects(transaction, /duplicate key/);
+				await assert.rejects(single.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
+			} finally {
+				await single.close();
+			}
+		});
+		it("leaves no failed transaction on the pool after a release with its error", async () => {
+			const driver = createDriver({ max: 1 });
+			try {
+				const connection = await driver.acquire();
+				await connection.execute(createStatement("BEGIN"));
+				const error = await connection.execute(createStatement("SELECT 1/0")).catch((error) => error);
+				await connection.release({ error });
+				await assert.rejects(driver.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
+			} finally {
+				await driver.close();
+			}
+		});
+		if (closesReservedConnections) {
+			for (const [state, text] of [["an open", "SELECT 1"], ["a failed", "SELECT 1/0"]]) it(`does not return a connection in ${state} transaction to the pool`, async () => {
+				const driver = createDriver({ max: 1 });
+				try {
+					const connection = await driver.acquire();
+					await connection.execute(createStatement("BEGIN"));
+					await connection.execute(createStatement(text)).catch(() => {});
+					await connection.release({ error: /* @__PURE__ */ new Error("failure") });
+					await assert.rejects(driver.execute(createStatement("SAVEPOINT probe")), /transaction blocks/);
+				} finally {
+					await driver.close();
+				}
+			});
+			it("rejects a transaction whose connection is lost and keeps the pool usable", async () => {
+				const single = createDatabase({ driver: createDriver({ max: 1 }) });
+				const { selectValue: selectValueOnSingle } = createStatementRunners(single);
+				try {
+					const transaction = single.transaction(async () => {
+						const pid = await selectValueOnSingle("SELECT pg_backend_pid()");
+						await selectValue("SELECT pg_terminate_backend($1)", [pid]);
+						await selectValueOnSingle("SELECT 1");
+					});
+					await assert.rejects(transaction, /Transaction rollback failed/);
+					assert.equal(await single.transaction(() => selectValueOnSingle("SELECT 'usable'")), "usable");
+				} finally {
+					await single.close();
+				}
+			});
+		}
+		it("isolates concurrent transactions on their own connections", async () => {
+			const bothStarted = Promise.withResolvers();
+			let startedCount = 0;
+			function runTransaction(label) {
+				return database.transaction(async () => {
+					const startPid = await selectValue("SELECT pg_backend_pid()");
+					await selectValue("SELECT set_config('kern.test', $1, true)", [label]);
+					startedCount += 1;
+					if (startedCount === 2) bothStarted.resolve();
+					await bothStarted.promise;
+					return {
+						startPid,
+						endPid: await selectValue("SELECT pg_backend_pid()"),
+						label: await selectValue("SELECT current_setting('kern.test')")
+					};
+				});
+			}
+			const [result1, result2] = await Promise.all([runTransaction("1"), runTransaction("2")]);
+			assert.equal(result1.endPid, result1.startPid);
+			assert.equal(result2.endPid, result2.startPid);
+			assert.notEqual(result1.startPid, result2.startPid);
+			assert.deepEqual([result1.label, result2.label], ["1", "2"]);
+		});
+		it("runs queries outside an open transaction on the pool", async () => {
+			const transactionStarted = Promise.withResolvers();
+			const outsideFinished = Promise.withResolvers();
+			const transactionPid = database.transaction(async () => {
+				await selectValue("SELECT set_config('kern.test', 'inside', true)");
+				transactionStarted.resolve();
+				await outsideFinished.promise;
+				return selectValue("SELECT pg_backend_pid()");
+			});
+			await transactionStarted.promise;
+			const outsidePid = await selectValue("SELECT pg_backend_pid()");
+			const outsideLabel = await selectValue("SELECT current_setting('kern.test', true)");
+			outsideFinished.resolve();
+			assert.notEqual(outsidePid, await transactionPid);
+			assert.notEqual(outsideLabel, "inside");
+		});
+		describe("closing", () => {
+			/** Creates a database whose client has one connection, so that a transaction waits for the connection of another one. */
+			function createClosableDatabase() {
+				return createDatabase({ driver: createDriver({ max: 1 }) });
+			}
+			it("waits for a running transaction and for a transaction waiting for a connection", async () => {
+				const database = createClosableDatabase();
+				const { promise: started, resolve: start } = Promise.withResolvers();
+				const { promise: closeRequested, resolve: requestClose } = Promise.withResolvers();
+				const { selectValue } = createStatementRunners(database);
+				const running = database.transaction(async () => {
+					start();
+					await closeRequested;
+					return selectValue("SELECT 'running'");
+				});
+				await started;
+				const waiting = database.transaction(() => selectValue("SELECT 'waiting'"));
+				const closing = database.close();
+				requestClose();
+				assert.equal(await running, "running");
+				assert.equal(await waiting, "waiting");
+				await closing;
+			});
+			it("waits for a statement on the pool waiting for a connection", async () => {
+				const database = createClosableDatabase();
+				const { promise: started, resolve: start } = Promise.withResolvers();
+				const { promise: closeRequested, resolve: requestClose } = Promise.withResolvers();
+				const { selectValue } = createStatementRunners(database);
+				const running = database.transaction(async () => {
+					start();
+					await closeRequested;
+				});
+				await started;
+				const waiting = selectValue("SELECT 'waiting'");
+				const closing = database.close();
+				requestClose();
+				await running;
+				assert.equal(await waiting, "waiting");
+				await closing;
+			});
+			it("waits for an in-flight pool query before closing", async () => {
+				const database = createClosableDatabase();
+				const { selectValue } = createStatementRunners(database);
+				await selectValue("SELECT 1");
+				const settled = [];
+				const query = selectValue("SELECT 'slept' FROM pg_sleep(0.2)");
+				query.then(() => settled.push("query"), () => {});
+				await database.close();
+				settled.push("database");
+				assert.equal(await query, "slept");
+				assert.deepEqual(settled, ["query", "database"]);
+			});
+		});
+		describe("in test transactions", () => {
+			const database = createDatabase({
+				driver: createDriver({ max: 2 }),
+				test: true
+			});
+			after(() => database.close());
+			const { testTransaction } = createTestHelpers(database, {
+				before,
+				after
+			});
+			const { runStatement, selectValue } = createStatementRunners(database);
+			it("discards only the rows of a rolled-back nested transaction", async () => {
+				const tag = defineTable("pg_nested_test", { id: integer });
+				const db = database.bind(defineSchema({ tag }));
+				const rows = await testTransaction(async () => {
+					await runStatement("CREATE TABLE pg_nested_test (id integer)");
+					await runStatement("INSERT INTO pg_nested_test VALUES (1)");
+					const failure = /* @__PURE__ */ new Error("failure");
+					const failed = database.transaction(async () => {
+						await runStatement("INSERT INTO pg_nested_test VALUES (2)");
+						throw failure;
+					});
+					await assert.rejects(failed, (error) => error === failure);
+					await database.transaction(() => runStatement("INSERT INTO pg_nested_test VALUES (3)"));
+					return await db.tag.select("id");
+				});
+				assert.deepEqual(rows.map(({ id }) => id).toSorted(), [1, 3]);
+			});
+			it("keeps the transaction usable after a failed statement in a nested transaction", async () => {
+				const value = await testTransaction(async () => {
+					await assert.rejects(database.transaction(() => runStatement("SELECT 1/0")), /division by zero/);
+					return await selectValue("SELECT 'usable'");
+				});
+				assert.equal(value, "usable");
+			});
+			it("keeps the changes of open fixtures for test transactions until each fixture closes", async () => {
+				const entry = defineTable("pg_fixture_test", { label: text });
+				const db = database.bind(defineSchema({ entry }));
+				const selectLabels = () => testTransaction(async () => {
+					return (await db.entry.select("label")).map(({ label }) => label).toSorted();
+				});
+				{
+					await using _run = await database.coordinator.createTestFixture(async () => {
+						await runStatement("CREATE TABLE pg_fixture_test (label text)");
+						await runStatement("INSERT INTO pg_fixture_test VALUES ('run')");
+					});
+					{
+						await using file = await database.coordinator.createTestFixture(async () => {
+							await runStatement("INSERT INTO pg_fixture_test VALUES ('file')");
+							return await db.entry.where({ label: "file" }).select("label");
+						});
+						assert.deepEqual(file.data, [{ label: "file" }]);
+						const inTest = await testTransaction(async () => {
+							await runStatement("INSERT INTO pg_fixture_test VALUES ('test')");
+							return (await db.entry.select("label")).map(({ label }) => label).toSorted();
+						});
+						assert.deepEqual(inTest, [
+							"file",
+							"run",
+							"test"
+						]);
+						assert.deepEqual(await selectLabels(), ["file", "run"]);
+					}
+					assert.deepEqual(await selectLabels(), ["run"]);
+				}
+				assert.equal(await testTransaction(() => selectValue("SELECT to_regclass('pg_fixture_test')")), null);
+			});
+			it("closes a database with an open fixture", async () => {
+				const closed = createDatabase({
+					driver: createDriver({ max: 1 }),
+					test: true
+				});
+				const fixture = await closed.coordinator.createTestFixture(() => closed.execute(createStatement("SELECT 1")));
+				await closed.close();
+				assert.throws(() => fixture.data, /Test fixture is closed/);
+			});
+			it("round-trips the built-in types", async () => {
+				const sample = defineTable("pg_type_test", {
+					bigint,
+					numeric: numeric.with(20, 6),
+					price: numeric.with(10, 2).transform({ decode: Number }),
+					double: doublePrecision,
+					flag: boolean,
+					id: uuid,
+					bytes: bytea,
+					at: timestamptz,
+					local: timestamp,
+					day: date,
+					clock: time,
+					span: interval,
+					doc: jsonb.of(),
+					labels: array(text.nullable()),
+					address: inet,
+					status: enumOf("pg_status_test", ["draft", "published"])
+				});
+				const db = database.bind(defineSchema({ sample }));
+				const values = {
+					bigint: 9007199254740993n,
+					numeric: "12345678901234.123456",
+					price: 12.5,
+					double: .1,
+					flag: true,
+					id: "0193d6b6-7c43-7000-8000-000000000001",
+					bytes: new Uint8Array([0, 255]),
+					at: "2026-01-15T07:00:00.123456Z",
+					local: "2026-01-15T10:00:00.000000",
+					day: "2026-01-15",
+					clock: "10:00:00.500000",
+					span: "1 day 02:00:00",
+					doc: { tags: ["a", "b"] },
+					labels: [
+						"a",
+						"b c",
+						null,
+						"NULL"
+					],
+					address: "192.168.0.1",
+					status: "published"
+				};
+				const rows = await testTransaction(async () => {
+					await runStatement("SET LOCAL TIME ZONE 'Asia/Bangkok'");
+					await runStatement("CREATE TYPE pg_status_test AS ENUM ('draft', 'published')");
+					await runStatement(`
+          CREATE TABLE pg_type_test (
+            bigint bigint, numeric numeric(20, 6), price numeric(10, 2), double double precision, flag boolean, id uuid,
+            bytes bytea, at timestamptz, local timestamp, day date, clock time, span interval,
+            doc jsonb, labels text[], address inet, status pg_status_test
+          )
+        `);
+					await runStatement(`
+          INSERT INTO pg_type_test VALUES (
+            9007199254740993, 12345678901234.123456, 12.50, 0.1, true, '0193d6b6-7c43-7000-8000-000000000001',
+            '\\x00ff', '2026-01-15 14:00:00.123456+07', '2026-01-15 10:00', '2026-01-15', '10:00:00.5',
+            '1 day 2 hours', '{"tags": ["a", "b"]}', '{a,"b c",NULL,"NULL"}', '192.168.0.1', 'published'
+          )
+        `);
+					return {
+						selected: await db.sample.select("*"),
+						matched: await db.sample.where(values).select("id")
+					};
+				});
+				assert.deepEqual(rows.selected, [values]);
+				assert.deepEqual(rows.matched, [{ id: values.id }]);
+			});
+			it("compares parameters of param with the operators of their types", async () => {
+				const probe = defineTable("pg_param_test", { id: integer });
+				const db = database.bind(defineSchema({ probe }));
+				const rows = await testTransaction(async () => {
+					await runStatement("CREATE TABLE pg_param_test (id integer)");
+					await runStatement("INSERT INTO pg_param_test VALUES (1)");
+					return await db.probe.where(() => and(param(integer, 2).lt(10), param(numeric.with(3, 1), "1.04").ne("1.0"), param(char, "ab").eq("ab"))).select("id");
+				});
+				assert.deepEqual(rows, [{ id: 1 }]);
+			});
+			it("round-trips date and time values of years outside 1 to 9999", async () => {
+				const moment = defineTable("pg_moment_test", {
+					id: integer,
+					at: timestamptz,
+					local: timestamp,
+					day: date
+				});
+				const db = database.bind(defineSchema({ moment }));
+				const values = [
+					{
+						id: 1,
+						at: "0000-01-01T00:00:00.000000Z",
+						local: "-000001-06-15T10:00:00.000000",
+						day: "-004712-01-01"
+					},
+					{
+						id: 2,
+						at: "+294276-12-31T23:59:59.999999Z",
+						local: "+010000-01-01T00:00:00.000000",
+						day: "+010000-01-01"
+					},
+					{
+						id: 3,
+						at: "9999-12-31T23:59:59.000000Z",
+						local: "9999-12-31T23:59:59.000000",
+						day: "+5874897-12-31"
+					}
+				];
+				const rows = await testTransaction(async () => {
+					await runStatement("SET LOCAL TIME ZONE 'Asia/Bangkok'");
+					await runStatement("CREATE TABLE pg_moment_test (id integer, at timestamptz, local timestamp, day date)");
+					await runStatement(`
+          INSERT INTO pg_moment_test VALUES
+            (1, '0001-01-01 00:00:00+00 BC', '0002-06-15 10:00 BC', '4713-01-01 BC'),
+            (2, '294276-12-31 23:59:59.999999+00', '10000-01-01', '10000-01-01'),
+            (3, '9999-12-31 23:59:59+00', '9999-12-31 23:59:59', '5874897-12-31')
+        `);
+					return {
+						selected: await db.moment.select("*"),
+						matched: await Promise.all(values.map((value) => db.moment.where(value).select("id")))
+					};
+				});
+				assert.deepEqual(rows.selected, values);
+				assert.deepEqual(rows.matched, [
+					[{ id: 1 }],
+					[{ id: 2 }],
+					[{ id: 3 }]
+				]);
+			});
+		});
+	});
+}
+export { createTestHelpers, describeDriverContract };

package/dist/{text-BUNl8wpl.mjs → text-BTFErHIi.mjs}

@@ -346,6 +346,20 @@ function toValueNode(value, type) {
 		type
 	});
 }
+/** Converts an operand into a node as `toValueNode` does, casting a plain value to `type`, so that its parameter has the type even where nothing else in the statement determines it. */
+function toCastValueNode(value, type) {
+	const node = toValueNode(value, type);
+	return node.kind === "param" ? createNode({
+		kind: "cast",
+		operand: node,
+		type
+	}) : node;
+}
+/** Converts an operand of the function `name` that skips `NULL`, such as the fallback of `coalesce`, into a node as `toValueNode` does, rejecting a plain `null` and `undefined`, which would have no effect or no value. */
+function toFunctionOperandNode(value, type, name) {
+	if (value === null || value === void 0) throw new TypeError(`${name} takes a value other than ${String(value)}`);
+	return toValueNode(value, type);
+}
 /** Creates an `IS NULL` node directly, so that resolving an object condition never calls an `isNull` operator replaced by a type. */
 function createIsNullNode(operand) {
 	return createNode({
@@ -378,19 +392,58 @@ const orderingOperators = {
 function createComparison(operator) {
 	return defineGenericOperator((self, value) => compare(self, operator, value));
 }
+// src/type/number.ts
+/** Defines a type of numbers with the operators of the built-in ones. */
+function defineNumberType(sqlType) {
+	return defineType({ sqlType }).transform({
+		decode: Number,
+		encode: (value) => String(value)
+	}).withOperators(orderingOperators);
+}
+let integerType;
+/** Returns the shared `integer` type used by built-in expressions and columns. */
+function getIntegerType() {
+	integerType ??= defineNumberType("integer");
+	return integerType;
+}
+// src/type/text.ts
+/** Defines a text type with the operators of the built-in text types. */
+function defineTextType(sqlType, castType) {
+	return defineType({
+		sqlType,
+		castType
+	}).withOperators(orderingOperators).withOperators(textOperators);
+}
+let textType;
+/** Returns the shared `text` type used by built-in expressions and columns. */
+function getTextType() {
+	textType ??= defineTextType("text");
+	return textType;
+}
 // src/expression/operators/text.ts
 /**
-* Operators of text types: pattern matching with `LIKE` and `ILIKE`.
+* Operators of text types: pattern matching with `LIKE` and `ILIKE`, `lower` and `upper`, which convert the case of the text, `trim`, which removes spaces from both of its ends, and `length`, which counts its characters.
 *
 * A string pattern is sent as it is; `param(type, pattern)` encodes it with a type.
 */
 const textOperators = {
 	like: /* @__PURE__ */ createPatternComparison("LIKE"),
-	ilike: /* @__PURE__ */ createPatternComparison("ILIKE")
+	ilike: /* @__PURE__ */ createPatternComparison("ILIKE"),
+	lower: /* @__PURE__ */ createTextConversion("lower"),
+	upper: /* @__PURE__ */ createTextConversion("upper"),
+	trim: /* @__PURE__ */ createTextConversion("btrim"),
+	length: /* @__PURE__ */ defineGenericOperator((self) => callTextFunction("length", self, getIntegerType()))
 };
 function createPatternComparison(operator) {
 	return defineGenericOperator((self, pattern) => toBooleanExpression(compareNodes(operator, toNode(self), pattern, void 0)));
 }
+function createTextConversion(name) {
+	return defineGenericOperator((self) => callTextFunction(name, self, getTextType()));
+}
+/** Calls a SQL function of text whose result has `type`, whatever the type of the expression: a decoder of a transformed type expects values that it encoded rather than results of the function. */
+function callTextFunction(name, self, type) {
+	return toExpression(createList(`${name}(`, [toNode(self)], ")"), type);
+}
 // src/type/codecs/bytea.ts
 const hexDigits = "0123456789abcdef";
 /** Encodes bytes as a hex `bytea` literal, such as `\\x00ff`. */
@@ -425,16 +478,10 @@ function formatTypeName(name, ...parameters) {
 	return defined.length === 0 ? name : `${name}(${defined.join(",")})`;
 }
 // src/type/builtins/text.ts
-function defineTextType(sqlType, castType) {
-	return defineType({
-		sqlType,
-		castType
-	}).withOperators(orderingOperators).withOperators(textOperators);
-}
 /** Variable-length string without a limit. */
-const text = /* @__PURE__ */ defineTextType("text");
+const text = /* @__PURE__ */ getTextType();
 /** Variable-length string; `varchar.with(length)` limits its length. */
 const varchar = /* @__PURE__ */ defineTextType("varchar").withParameters((length) => formatTypeName("varchar", length));
 /** Fixed-length string that PostgreSQL pads with spaces; `char` alone has length 1, and `char.with(length)` sets the length. */
 const char = /* @__PURE__ */ defineTextType("char", "bpchar").withParameters((length) => formatTypeName("char", length));
-export { createList as A, isType as C, isEqualityCompatible as D, hasEquality as E, oneNode as F, trueNode as I, createSelectNode as M, falseNode as N, valuesQueryNode as O, noFilters as P, defineType as S, equalityOperators as T, toBooleanExpression as _, stringifyJson as a, toValueNode as b, textOperators as c, compareNodes as d, createIsNullNode as f, operandNode as g, isOperandSource as h, formatTypeName as i, createNode as j, defineGenericOperator as k, orderingOperators as l, isExpression as m, text as n, decodeBytea as o, getType as p, varchar as r, encodeBytea as s, char as t, compare as u, toExpression as v, Column as w, getBooleanType as x, toNode as y };
+export { hasEquality as A, trueNode as B, toNode as C, isType as D, defineType as E, createNode as F, createSelectNode as I, falseNode as L, valuesQueryNode as M, defineGenericOperator as N, Column as O, createList as P, noFilters as R, toFunctionOperandNode as S, getBooleanType as T, isOperandSource as _, stringifyJson as a, toCastValueNode as b, textOperators as c, orderingOperators as d, compare as f, isExpression as g, getType as h, formatTypeName as i, isEqualityCompatible as j, equalityOperators as k, defineNumberType as l, createIsNullNode as m, text as n, decodeBytea as o, compareNodes as p, varchar as r, encodeBytea as s, char as t, getIntegerType as u, operandNode as v, toValueNode as w, toExpression as x, toBooleanExpression as y, oneNode as z };