@shivaedev/sql 0.0.0 → 0.22.0

package/src/repositoryQueries.ts

@@ -0,0 +1,107 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import type { Fragment } from "effect/sql/Statement";
+import type { Aggregate } from "#aggregateQuery.ts";
+import { latestPerGroup as makeLatestPerGroup } from "#latestPerGroup.ts";
+import { makeAggregate } from "#makeAggregate.ts";
+import { makeQueryClauses } from "#makeQueryClauses.ts";
+import type { FindMany, LatestPerGroup } from "#repository.ts";
+import { makeFilter } from "#repositoryFilter.ts";
+
+type Key<TModel extends Model.Any> = Extract<keyof TModel["fields"] & keyof Row<TModel>, string>;
+type Row<TModel extends Model.Any> = Schema.Struct.Type<TModel["fields"]>;
+
+const CountResult = Schema.Tuple([Schema.Struct({ count: Schema.NumberFromString })]);
+
+export interface RepositorySelect<TFields extends Schema.Struct.Fields, TServices = never> {
+	readonly fields: TFields;
+	readonly statement: Effect.Effect<Fragment, Schema.SchemaError, TServices>;
+}
+
+export interface Queries<TModel extends Model.Any> {
+	aggregate: Aggregate<TModel>;
+	count: (
+		query?: Pick<FindMany<TModel, Key<TModel>>, "where">,
+	) => Effect.Effect<number, SqlError | Schema.SchemaError, TModel["fields"][Key<TModel>]["EncodingServices"]>;
+	findMany: <TKey extends Key<TModel> = Key<TModel>>(
+		query?: FindMany<TModel, TKey>,
+	) => Effect.Effect<
+		Pick<Row<TModel>, TKey>[],
+		SqlError | Schema.SchemaError,
+		TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][TKey]["DecodingServices"]
+	>;
+	latestPerGroup: (
+		query: LatestPerGroup<TModel>,
+	) => Effect.Effect<
+		Row<TModel>[],
+		SqlError | Schema.SchemaError,
+		TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][Key<TModel>]["DecodingServices"]
+	>;
+	select: <TKey extends Key<TModel> = Key<TModel>>(
+		query?: FindMany<TModel, TKey>,
+	) => RepositorySelect<Pick<TModel["fields"], TKey>, TModel["fields"][Key<TModel>]["EncodingServices"]>;
+}
+
+export function makeQueries<TModel extends Model.Any>(
+	model: TModel,
+	sql: SqlClient.SqlClient,
+	options: {
+		readonly tableName: string;
+		readonly spanPrefix: string;
+	},
+): Queries<TModel> {
+	const { fieldAt, where } = makeFilter(model, sql);
+	const readLatest = makeLatestPerGroup(model, sql, options.tableName);
+	const { decodeLimit, orderClause, limitClause } = makeQueryClauses(sql, fieldAt);
+	const aggregate = makeAggregate(model, sql, options);
+	function count(query?: Pick<FindMany<TModel, Key<TModel>>, "where">): ReturnType<Queries<TModel>["count"]>;
+	function count(query: Pick<FindMany<TModel, Key<TModel>>, "where"> = {}): Effect.Effect<number, SqlError | Schema.SchemaError, unknown> {
+		return Effect.gen(function* () {
+			const predicate = yield* where(query.where, true, true);
+			const rows = yield* sql`select cast(count(*) as text) as count from ${sql(options.tableName)} where ${predicate}`;
+			const [result] = yield* Schema.decodeUnknownEffect(CountResult)(rows);
+			return result.count;
+		}).pipe(Effect.withSpan(`${options.spanPrefix}.count`));
+	}
+	function select<TKey extends Key<TModel> = Key<TModel>>(
+		query?: FindMany<TModel, TKey>,
+	): RepositorySelect<Pick<TModel["fields"], TKey>, TModel["fields"][Key<TModel>]["EncodingServices"]>;
+	function select(query: FindMany<TModel, Key<TModel>> = {}): RepositorySelect<Schema.Struct.Fields, unknown> {
+		const keys = query.select ?? Object.keys(model.fields);
+		const fields = Object.fromEntries(keys.map((key) => [key, model.fields[key]]));
+		const statement = Effect.gen(function* () {
+			yield* Effect.forEach(keys, fieldAt);
+			const predicate = yield* where(query.where, true, true);
+			const order = yield* orderClause(query.orderBy);
+			const limit = yield* limitClause(query.limit);
+			return sql`select ${sql.csv(keys.map((key) => sql`${sql(key)}`))} from ${sql(options.tableName)} where ${predicate} ${order} ${limit}`;
+		});
+		return { fields, statement };
+	}
+	function findMany<TKey extends Key<TModel> = Key<TModel>>(
+		query?: FindMany<TModel, TKey>,
+	): Effect.Effect<
+		Pick<Row<TModel>, TKey>[],
+		SqlError | Schema.SchemaError,
+		TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][TKey]["DecodingServices"]
+	>;
+	// Object.fromEntries erases the selected key-to-schema correspondence, so the typed overload restates it.
+	function findMany(query: FindMany<TModel, Key<TModel>> = {}): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> {
+		return Effect.gen(function* () {
+			const selected = select(query);
+			const rows = yield* sql`${yield* selected.statement}`;
+			return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(selected.fields)))(rows);
+		}).pipe(Effect.withSpan(`${options.spanPrefix}.findMany`));
+	}
+	function latestPerGroup(query: LatestPerGroup<TModel>): ReturnType<Queries<TModel>["latestPerGroup"]>;
+	function latestPerGroup(query: LatestPerGroup<TModel>): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> {
+		return Effect.gen(function* () {
+			const order = yield* orderClause(query.orderBy);
+			const rowLimit = yield* decodeLimit(query.limit);
+			return yield* readLatest(query, order, rowLimit);
+		}).pipe(Effect.withSpan(`${options.spanPrefix}.latestPerGroup`));
+	}
+	return { aggregate, count, findMany, latestPerGroup, select };
+}

package/src/repositoryWrites.ts

@@ -0,0 +1,70 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import { type SqlClient, SqlSchema } from "effect/sql";
+import type { RepositoryChanges } from "./repositoryChanges.ts";
+import { makeFilter } from "./repositoryFilter.ts";
+
+export function repositoryWrites(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: { readonly idColumns: readonly string[]; readonly tableName: string; readonly spanPrefix: string },
+	changes: RepositoryChanges,
+) {
+	const { idColumns, tableName, spanPrefix } = options;
+	const { where } = makeFilter(model, sql);
+	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+	const filterRecord = Schema.decodeUnknownEffect(Schema.Record(Schema.PropertyKey, Schema.Unknown));
+	function predicate(input: Readonly<Record<string, unknown>>) {
+		return sql.and(idColumns.map((column) => sql`${sql(column)} = ${input[column]}`));
+	}
+	function insert(input: unknown) {
+		return Effect.flatMap(record(input), (row) =>
+			(Object.keys(row).length === 0
+				? sql`insert into ${sql(tableName)} default values returning *`
+				: sql`insert into ${sql(tableName)} ${sql.insert(row)} returning *`
+			).pipe(Effect.tap(changes.record)),
+		);
+	}
+	function update(input: unknown) {
+		return Effect.flatMap(record(input), (row) =>
+			sql`update ${sql(tableName)} set ${sql.update(row, idColumns)} where ${predicate(row)} returning *`.pipe(Effect.tap(changes.record)),
+		);
+	}
+	const insertRow = SqlSchema.findOne({ execute: insert, Request: model.insert, Result: model });
+	const insertVoid = SqlSchema.void({ execute: insert, Request: model.insert });
+	const updateRow = SqlSchema.findOne({ execute: update, Request: model.update, Result: model });
+	const updateVoid = SqlSchema.void({ execute: update, Request: model.update });
+	const idColumn = idColumns[0] ?? "";
+	const key = model.fields[idColumn];
+	if (key === undefined) {
+		throw new Error("Unknown repository ID column");
+	}
+	const isKey = Schema.is(key);
+	const removeByKey = SqlSchema.void({
+		execute: (id) =>
+			Effect.flatMap(record({ [idColumn]: id }), (encoded) =>
+				sql`delete from ${sql(tableName)} where ${predicate(encoded)} returning *`.pipe(Effect.tap(changes.record)),
+			),
+		Request: key,
+	});
+	function remove(input: unknown) {
+		return idColumns.length === 1 && isKey(input)
+			? removeByKey(input)
+			: Effect.flatMap(filterRecord(input), (filter) =>
+					Effect.flatMap(where(filter, true), (clause) =>
+						sql`delete from ${sql(tableName)} where ${clause} returning *`.pipe(Effect.tap(changes.record), Effect.asVoid),
+					),
+				);
+	}
+	return {
+		delete: (id: unknown) => changes.write(remove(id)).pipe(Effect.withSpan(`${spanPrefix}.delete`)),
+		insert: (input: unknown) =>
+			changes.write(insertRow(input).pipe(Effect.catchTag("NoSuchElementError", Effect.die))).pipe(Effect.withSpan(`${spanPrefix}.insert`)),
+		insertVoid: (input: unknown) => changes.write(insertVoid(input)).pipe(Effect.withSpan(`${spanPrefix}.insertVoid`)),
+		update: (input: unknown, settings?: { readonly onMissing: "fail" }) =>
+			changes
+				.write(settings?.onMissing === "fail" ? updateRow(input) : updateRow(input).pipe(Effect.catchTag("NoSuchElementError", Effect.die)))
+				.pipe(Effect.withSpan(`${spanPrefix}.update`)),
+		updateVoid: (input: unknown) => changes.write(updateVoid(input)).pipe(Effect.withSpan(`${spanPrefix}.updateVoid`)),
+	};
+}

package/src/testing.ts

@@ -0,0 +1,38 @@
+import { Data, Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { ChangeObserver, transact } from "./transact.ts";
+
+export class UnannouncedWrites extends Data.TaggedError("UnannouncedWrites")<{ readonly tables: readonly string[] }> {}
+
+interface TableWrites {
+	readonly relid: number;
+	readonly relname: string;
+	readonly writes: number;
+}
+
+export const withChangeCoverage = Effect.fn("Changes.withChangeCoverage")(function* <A, E, R>(body: Effect.Effect<A, E, R>) {
+	const observer = yield* ChangeObserver;
+	const sql = yield* SqlClient.SqlClient;
+	const named = new Set<unknown>();
+	const written = sql<TableWrites>`select relid, relname, (n_tup_ins + n_tup_upd + n_tup_del)::int as writes from pg_stat_xact_user_tables`;
+	const checked = Effect.gen(function* () {
+		const before = new Map((yield* written).map((row) => [row.relid, row.writes]));
+		const result = yield* body;
+		const missing = (yield* written).filter((row) => row.writes > (before.get(row.relid) ?? 0) && !named.has(row.relname));
+		if (missing.length > 0) {
+			return yield* Effect.fail(new UnannouncedWrites({ tables: missing.map((row) => row.relname).sort() }));
+		}
+		return result;
+	});
+	return yield* checked.pipe(
+		transact({ onSqlError: (error) => error }),
+		Effect.provideService(ChangeObserver, (event) => {
+			if (event._tag === "Recorded") {
+				for (const key of event.changes) {
+					named.add(key);
+				}
+			}
+			return observer(event);
+		}),
+	);
+});

package/src/transact.ts

@@ -0,0 +1,70 @@
+import { Effect, Hash } from "effect";
+import { dual } from "effect/Function";
+import type { ReadonlyRecord } from "effect/Record";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { SqlClient } from "effect/sql";
+import { isSqlError, type SqlError } from "effect/sql/SqlError";
+import { makeChannel } from "@shivaedev/changes/channel.ts";
+
+export type InvalidationKeys = readonly unknown[] | ReadonlyRecord<string, readonly unknown[]>;
+
+function hashOf(value: unknown): unknown {
+	return typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean"
+		? String(value)
+		: Hash.hash(value);
+}
+
+function isList(keys: InvalidationKeys): keys is readonly unknown[] {
+	return Array.isArray(keys);
+}
+
+function flatten(keys: InvalidationKeys): readonly unknown[] {
+	return isList(keys) ? keys : Object.entries(keys).flatMap(([name, ids]) => [name, ...ids.map((id) => `${name}:${hashOf(id)}`)]);
+}
+
+const guard = Effect.fn("Transact.guard")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const native = yield* Effect.serviceOption(sql.transactionService);
+	if (native._tag === "Some") {
+		return yield* Effect.die(
+			new Error("transact cannot announce changes after a transaction it does not own; begin the outer transaction with transact"),
+		);
+	}
+});
+
+const invalidations = makeChannel<unknown, SqlClient.SqlClient | Reactivity.Reactivity, SqlError>({
+	name: "@shivaedev/sql/transact",
+	owner: Effect.map(SqlClient.SqlClient, (sql) => sql.transactionService),
+	publish: (keys) => Reactivity.invalidate(keys),
+	unowned: guard(),
+});
+
+export const ChangeObserver = invalidations.Observer;
+export const BeforeCommit = invalidations.BeforeCommit;
+export const CommittedSink = invalidations.CommittedSink;
+
+export const invalidateOnCommit = Effect.fn("Transact.invalidateOnCommit")(function* (keys: InvalidationKeys) {
+	yield* invalidations.record(flatten(keys));
+});
+
+export interface TransactOptions<TError> {
+	readonly onSqlError: (error: SqlError) => TError;
+}
+
+export const transact: {
+	<TError>(
+		options: TransactOptions<TError>,
+	): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, Exclude<E, SqlError> | TError, R | SqlClient.SqlClient | Reactivity.Reactivity>;
+	<A, E, R, TError>(
+		effect: Effect.Effect<A, E, R>,
+		options: TransactOptions<TError>,
+	): Effect.Effect<A, Exclude<E, SqlError> | TError, R | SqlClient.SqlClient | Reactivity.Reactivity>;
+} = dual(
+	2,
+	Effect.fn("Transact.transact")(function* <A, E, R, TError>(effect: Effect.Effect<A, E, R>, options: TransactOptions<TError>) {
+		const sql = yield* SqlClient.SqlClient;
+		return yield* invalidations
+			.within(sql.withTransaction)(effect)
+			.pipe(Effect.catchIf(isSqlError, (error) => Effect.fail(options.onSqlError(error))));
+	}),
+);

package/src/tupleIn.ts

@@ -0,0 +1,44 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+
+export const tupleFilter = Symbol("sql/tupleIn");
+type Row<TModel extends Model.Any> = Schema.Struct.Type<TModel["fields"]>;
+type Key<TModel extends Model.Any> = Extract<keyof Row<TModel>, string>;
+
+export interface TupleFilter<TModel extends Model.Any> {
+	readonly [tupleFilter]: {
+		readonly model: TModel;
+		readonly fields: readonly Key<TModel>[];
+		readonly values: readonly (readonly unknown[])[];
+	};
+}
+
+export function tupleIn<TModel extends Model.Any, const TFields extends readonly [Key<TModel>, Key<TModel>, ...Key<TModel>[]]>(
+	model: TModel,
+	fields: TFields,
+	values: readonly { readonly [TIndex in keyof TFields]: Row<TModel>[TFields[TIndex]] }[],
+): TupleFilter<TModel> {
+	return { [tupleFilter]: { fields, model, values } };
+}
+
+export function tuplePredicate(
+	input: Partial<TupleFilter<Model.Any>>,
+	sql: SqlClient.SqlClient,
+	fieldAt: (key: string) => Effect.Effect<Schema.Constraint, Schema.SchemaError>,
+) {
+	const tuple = input[tupleFilter];
+	if (tuple === undefined) {
+		return Effect.succeed(undefined);
+	}
+	return Effect.gen(function* () {
+		const fields = yield* Effect.forEach(tuple.fields, fieldAt);
+		const encode = Schema.encodeUnknownEffect(Schema.Tuple(fields));
+		const columns = sql.csv(tuple.fields.map((field) => sql`${sql(field)}`));
+		// Row comparisons retain column type inference for string-encoded numerics without PostgreSQL's deeply nested row-IN rewrite.
+		const rows = yield* Effect.forEach(tuple.values, (value) =>
+			Effect.map(encode(value), (encoded) => sql`(${columns}) = (${sql.csv(encoded.map((entry) => sql`${entry}`))})`),
+		);
+		return rows.length === 0 ? sql`1 = 0` : sql.or(rows);
+	});
+}

package/src/versionedRepository.ts

@@ -0,0 +1,108 @@
+import { Effect, Option, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient, SqlModel } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import type { PrimaryKey, Repository } from "#compositeRepository.ts";
+import type { OptimisticConcurrencyError } from "#repository.ts";
+import { type VersionedOptions, versionedStatements } from "#versionedStatements.ts";
+import type { RepositoryChanges } from "./repositoryChanges.ts";
+
+export type IdColumn<TModel extends Model.Any> = keyof TModel["Type"] & keyof TModel["update"]["Type"] & keyof TModel["fields"];
+export type VersionColumn<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = {
+	[TKey in Extract<keyof TModel["fields"] & keyof TModel["update"]["Type"], string>]: TModel["fields"][TKey] extends Schema.ConstraintCodec<
+		number,
+		number,
+		never,
+		never
+	>
+		? TModel["update"]["Type"] extends { readonly [TField in TKey]: number }
+			? TKey
+			: never
+		: never;
+}[Extract<keyof TModel["fields"] & keyof TModel["update"]["Type"], string>] &
+	Exclude<keyof TModel["fields"], (TId extends readonly PropertyKey[] ? TId[number] : TId) | keyof TModel["insert"]["Type"]>;
+
+export type NativeRepository<TModel extends Model.Any, TId extends IdColumn<TModel>> = Effect.Success<
+	ReturnType<typeof SqlModel.makeRepository<TModel, TId>>
+>;
+type WriteError = SqlError | Schema.SchemaError | OptimisticConcurrencyError;
+type KeyColumn<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = TId extends readonly IdColumn<TModel>[]
+	? TId[number]
+	: Extract<TId, IdColumn<TModel>>;
+export interface VersionedWrites<TModel extends Model.Any, TId extends PrimaryKey<TModel>> {
+	readonly delete: (
+		id: TId extends readonly IdColumn<TModel>[] ? Pick<TModel["Type"], TId[number]> : TModel["fields"][Extract<TId, IdColumn<TModel>>]["Type"],
+		expectedVersion: number,
+	) => Effect.Effect<void, WriteError, TModel["fields"][KeyColumn<TModel, TId>]["EncodingServices"]>;
+	readonly insert: Repository<TModel, TId>["insert"];
+	readonly insertVoid: Repository<TModel, TId>["insertVoid"];
+	readonly update: (
+		input: TModel["update"]["Type"],
+	) => Effect.Effect<TModel["Type"], WriteError, TModel["update"]["EncodingServices"] | TModel["DecodingServices"]>;
+	readonly updateVoid: (input: TModel["update"]["Type"]) => Effect.Effect<void, WriteError, TModel["update"]["EncodingServices"]>;
+}
+
+export function makeVersionedWrites(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: VersionedOptions & { readonly changes: RepositoryChanges; readonly spanPrefix: string },
+) {
+	const { spanPrefix, changes } = options;
+	const statements = versionedStatements(model, sql, options);
+	const decodeRow = Schema.decodeUnknownEffect(model);
+	function insert(input: unknown) {
+		return Effect.gen(function* () {
+			const statement = yield* statements.insert(input);
+			const rows = yield* sql`${statement} returning *`;
+			yield* changes.record(rows);
+			return yield* decodeRow(rows[0]);
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.insert`));
+	}
+	function insertVoid(input: unknown) {
+		return Effect.gen(function* () {
+			const statement = yield* statements.insert(input);
+			const rows = yield* sql`${statement} returning ${statements.returningKeys}`;
+			yield* changes.record(rows);
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.insertVoid`));
+	}
+	function insertOrIgnore(input: unknown) {
+		return Effect.gen(function* () {
+			const statement = yield* statements.insert(input, true);
+			const rows = yield* sql`${statement} returning *`;
+			yield* changes.record(rows);
+			return rows.length === 0 ? Option.none() : Option.some(yield* decodeRow(rows[0]));
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.insertOrIgnore`));
+	}
+	function update(input: Readonly<Record<string, unknown>>) {
+		return Effect.gen(function* () {
+			const { statement, classify } = yield* statements.update(input);
+			const rows = yield* sql`${statement} returning *`;
+			if (rows.length === 0) {
+				return yield* classify();
+			}
+			yield* changes.record(rows);
+			return yield* decodeRow(rows[0]);
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.update`));
+	}
+	function updateVoid(input: Readonly<Record<string, unknown>>) {
+		return Effect.gen(function* () {
+			const { statement, classify } = yield* statements.update(input);
+			const rows = yield* sql`${statement} returning ${statements.returningKeys}`;
+			if (rows.length === 0) {
+				return yield* classify();
+			}
+			yield* changes.record(rows);
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.updateVoid`));
+	}
+	function deleteRow(id: unknown, expected: number) {
+		return Effect.gen(function* () {
+			const { statement, classify } = yield* statements.remove(id, expected);
+			const rows = yield* sql`${statement} returning ${statements.returningKeys}`;
+			if (rows.length === 0) {
+				return yield* classify();
+			}
+			yield* changes.record(rows);
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.delete`));
+	}
+	return { delete: deleteRow, insert, insertVoid, update, updateVoid, ...(options.conflictColumns === undefined ? {} : { insertOrIgnore }) };
+}

package/src/versionedStatements.ts

@@ -0,0 +1,90 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import { makeConflictClause } from "#makeConflictClause.ts";
+import type { OptimisticConcurrencyError } from "#repository.ts";
+
+const Version = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
+export interface VersionedOptions {
+	readonly conflict: (id: unknown, expectedVersion: number, reason: "missing" | "stale") => OptimisticConcurrencyError;
+	readonly conflictColumns?: readonly string[];
+	readonly conflictWhere?: Readonly<Record<string, unknown>>;
+	readonly idColumns: readonly string[];
+	readonly tableName: string;
+	readonly versionColumn: string;
+}
+
+export function versionedStatements(model: Model.Any, sql: SqlClient.SqlClient, options: VersionedOptions) {
+	const { tableName, idColumns, versionColumn, conflict } = options;
+	const fields = Object.fromEntries(
+		idColumns.map((column) => {
+			const field = model.fields[column];
+			if (field === undefined) {
+				throw new Error(`Unknown ID column: ${column}`);
+			}
+			return [column, field];
+		}),
+	);
+	const encodeKey = Schema.encodeEffect(Schema.Struct(fields));
+	const versionSchema = model.fields[versionColumn];
+	if (versionSchema === undefined) {
+		throw new Error(`Unknown version column: ${versionColumn}`);
+	}
+	const encodeVersion = Schema.encodeEffect(versionSchema);
+	const encodeInsert = Schema.encodeEffect(model.insert);
+	const encodeUpdate = Schema.encodeEffect(model.update);
+	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+	const validateVersion = Schema.decodeUnknownEffect(Version);
+	const clause =
+		options.conflictColumns === undefined ? undefined : makeConflictClause(model, sql, { ...options, conflictColumns: options.conflictColumns });
+	const returningKeys = sql.csv(idColumns.map((column) => sql`${sql(column)}`));
+	function key(input: unknown) {
+		return idColumns.length === 1 ? { [idColumns[0] ?? ""]: input } : input;
+	}
+	function inputKey(input: Readonly<Record<string, unknown>>) {
+		return idColumns.length === 1 ? input[idColumns[0] ?? ""] : Object.fromEntries(idColumns.map((column) => [column, input[column]]));
+	}
+	function predicate(encoded: Readonly<Record<string, unknown>>) {
+		return sql.and(idColumns.map((column) => sql`${sql(column)} = ${encoded[column]}`));
+	}
+	function classify(id: unknown, encoded: Readonly<Record<string, unknown>>, expected: number) {
+		return Effect.gen(function* () {
+			const rows = yield* sql`select 1 from ${sql(tableName)} where ${predicate(encoded)}`;
+			return yield* Effect.fail(conflict(id, expected, rows.length === 0 ? "missing" : "stale"));
+		});
+	}
+	function insert(input: unknown, ignore = false) {
+		return Effect.gen(function* () {
+			const encoded = { ...(yield* record(yield* encodeInsert(input))), [versionColumn]: 0 };
+			const suffix = ignore && clause !== undefined ? yield* clause(encoded) : sql``;
+			return sql`insert into ${sql(tableName)} ${sql.insert(encoded)} ${suffix}`;
+		});
+	}
+	function update(input: Readonly<Record<string, unknown>>) {
+		return Effect.gen(function* () {
+			const encoded = yield* record(yield* encodeUpdate(input));
+			const expectedVersion = yield* validateVersion(encoded[versionColumn]);
+			const assignments = Object.entries(encoded).filter(([column]) => !idColumns.includes(column) && column !== versionColumn);
+			const set = sql.csv([
+				...assignments.map(([column, value]) => sql`${sql(column)} = ${value}`),
+				sql`${sql(versionColumn)} = ${sql(versionColumn)} + 1`,
+			]);
+			return {
+				classify: () => classify(inputKey(input), encoded, expectedVersion),
+				statement: sql`update ${sql(tableName)} set ${set} where ${predicate(encoded)} and ${sql(versionColumn)} = ${expectedVersion}`,
+			};
+		});
+	}
+	function remove(id: unknown, expected: number) {
+		return Effect.gen(function* () {
+			const expectedVersion = yield* validateVersion(yield* encodeVersion(expected));
+			const yieldedKey = yield* record(key(id));
+			const encoded = yield* record(yield* encodeKey(yieldedKey));
+			return {
+				classify: () => classify(inputKey(yieldedKey), encoded, expectedVersion),
+				statement: sql`delete from ${sql(tableName)} where ${predicate(encoded)} and ${sql(versionColumn)} = ${expectedVersion}`,
+			};
+		});
+	}
+	return { insert, remove, returningKeys, update };
+}