@shivaedev/sql 0.37.0 → 0.39.0

package/src/orderedChildStatements.ts

@@ -0,0 +1,76 @@
+import { Cause, Data, Effect, Equal, Schema } from "effect";
+import type { Model } from "effect/schema";
+import { SqlClient, SqlSchema } from "effect/sql";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
+
+export class ChildOrderError extends Data.TaggedError("ChildOrderError")<{
+	readonly reason: "membership" | "position";
+}> {}
+
+export interface ChildOrderOptions {
+	readonly idColumn: string;
+	readonly parentColumn: string;
+	readonly parentIdColumn: string;
+	readonly parentTable: string;
+	readonly positionColumn: string;
+	readonly tableName: string;
+}
+
+export const orderedChildStatements = Effect.fnUntraced(function* (model: Model.Any, options: ChildOrderOptions, changes: RepositoryChanges) {
+	const sql = yield* SqlClient.SqlClient;
+	const { idColumn, parentColumn, parentTable, parentIdColumn, positionColumn, tableName } = options;
+	const parent = model.fields[parentColumn];
+	const idField = model.fields[idColumn];
+	if (parent === undefined || idField === undefined) {
+		return yield* Effect.die(new Error("Unknown ordered child key column"));
+	}
+	const encodeParent = Schema.encodeEffect(parent);
+	const encodeId = Schema.encodeEffect(idField);
+	const lock = Effect.fnUntraced(function* (value: unknown) {
+		const encoded = yield* encodeParent(value);
+		const rows = yield* sql`select ${sql(parentIdColumn)} from ${sql(parentTable)} where ${sql(parentIdColumn)} = ${encoded} for update`;
+		if (rows.length === 0) {
+			return yield* new Cause.NoSuchElementError();
+		}
+		return encoded;
+	});
+	const children = SqlSchema.findAll({
+		execute: (encodedParent) =>
+			sql`select ${sql(idColumn)} as ${sql("childId")} from ${sql(tableName)} where ${sql(parentColumn)} = ${encodedParent} order by ${sql(positionColumn)}, ${sql(idColumn)}`,
+		Request: Schema.Unknown,
+		Result: Schema.Struct({ childId: idField }),
+	});
+
+	const write = Effect.fnUntraced(function* (encodedParent: unknown, ids: readonly unknown[]) {
+		if (ids.length === 0) {
+			return;
+		}
+		const encoded = yield* Effect.forEach(ids, (value) => encodeId(value));
+		const positions = sql.join(" ", false)(encoded.map((value, index) => sql`when ${value} then ${index}`));
+		const rows = yield* sql`update ${sql(tableName)} set ${sql(positionColumn)} = case ${sql(idColumn)} ${positions} end
+			where ${sql(parentColumn)} = ${encodedParent} returning ${changes.returning()}`;
+		yield* changes.record(rows);
+	});
+	const reorder = Effect.fnUntraced(function* (value: unknown, ids: readonly unknown[]) {
+		const encodedParent = yield* lock(value);
+		const current = yield* children(encodedParent);
+		if (ids.length !== current.length || current.some(({ childId }) => ids.filter((key) => Equal.equals(childId, key)).length !== 1)) {
+			return yield* new ChildOrderError({ reason: "membership" });
+		}
+		yield* write(encodedParent, ids);
+	});
+	const move = Effect.fnUntraced(function* (value: unknown, child: unknown, position: number) {
+		const encodedParent = yield* lock(value);
+		const current = yield* children(encodedParent);
+		if (!current.some(({ childId }) => Equal.equals(childId, child))) {
+			return yield* new ChildOrderError({ reason: "membership" });
+		}
+		if (!Number.isInteger(position) || position < 0 || position >= current.length) {
+			return yield* new ChildOrderError({ reason: "position" });
+		}
+		const ids = current.map(({ childId }) => childId).filter((key) => !Equal.equals(key, child));
+		ids.splice(position, 0, child);
+		yield* write(encodedParent, ids);
+	});
+	return { lock, move, reorder };
+});

package/src/registerWorkerRelease.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import type { initializeWorkerRelease } from "./initializeWorkerRelease.ts";
+
+export function registerWorkerRelease(state: Effect.Success<typeof initializeWorkerRelease>) {
+	return function register<E>(control: (active: boolean) => Effect.Effect<void, E>) {
+		const attach = Effect.gen(function* () {
+			state.controls.add(control);
+			yield* control(state.active);
+		});
+		const detach = Effect.sync(() => {
+			state.controls.delete(control);
+		});
+		return Effect.acquireRelease(state.locked(attach), () => state.locked(detach));
+	};
+}

package/src/repository.ts

@@ -10,7 +10,8 @@ import { repositoryChanges } from "#repositoryChanges.ts";
 import { type BucketRegistrationError, type RepositoryOptions, validateRepositoryCollection } from "#repositoryCollection.ts";
 import type { FindManyFilter, RepositoryFilter, RepositoryListFilter } from "#repositoryFilter.ts";
 import { makeQueries, type Queries } from "#repositoryQueries.ts";
-import { type IdColumn, makeVersionedWrites, type VersionColumn, type VersionedWrites } from "#versionedRepository.ts";
+import type { VersionedRepositoryShape } from "#VersionedRepositoryShape.ts";
+import { type IdColumn, makeVersionedWrites, type VersionColumn } from "#versionedRepository.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"]>;
@@ -27,6 +28,8 @@ export interface FindMany<TModel extends Model.Any, TKey extends Key<TModel>> {
 	readonly where?: FindManyFilter<TModel>;
 }
 
+export type FindOne<TModel extends Model.Any, TKey extends Key<TModel>> = Omit<FindMany<TModel, TKey>, "limit">;
+
 export interface LatestPerGroup<TModel extends Model.Any> {
 	readonly limit: number;
 	readonly orderBy: readonly [OrderBy<TModel>, ...OrderBy<TModel>[]];
@@ -41,39 +44,37 @@ export class OptimisticConcurrencyError extends Data.TaggedError("OptimisticConc
 	readonly reason: "missing" | "stale";
 }> {}
 
-type VersionedRepository<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = Omit<
-	Repository<TModel, TId>,
-	keyof VersionedWrites<TModel, TId>
-> &
-	VersionedWrites<TModel, TId> &
-	Queries<TModel>;
-
 export function makeRepository<
 	TModel extends Model.Any,
 	const TId extends PrimaryKey<TModel>,
 	const TConflict extends ConflictColumns<TModel>,
 	const TWhere extends keyof RepositoryFilter<TModel> = never,
+	const TVersion extends VersionColumn<TModel, TId> = VersionColumn<TModel, TId>,
 >(
 	model: TModel,
 	options: RepositoryOptions<TId> & {
-		readonly versionColumn: VersionColumn<TModel, TId>;
+		readonly versionColumn: TVersion;
 		readonly conflictColumns: TConflict;
 		readonly conflictWhere?: Pick<RepositoryFilter<TModel>, TWhere>;
 	},
 ): Effect.Effect<
-	VersionedRepository<TModel, TId> &
+	VersionedRepositoryShape<TModel, TId, TVersion> &
 		Pick<ConflictWrites<TModel, never, TModel["fields"][Extract<TWhere, keyof TModel["fields"]>]["EncodingServices"]>, "insertOrIgnore">,
 	BucketRegistrationError,
 	SqlClient.SqlClient
 >;
-export function makeRepository<TModel extends Model.Any, const TId extends PrimaryKey<TModel>>(
+export function makeRepository<
+	TModel extends Model.Any,
+	const TId extends PrimaryKey<TModel>,
+	const TVersion extends VersionColumn<TModel, TId> = VersionColumn<TModel, TId>,
+>(
 	model: TModel,
 	options: RepositoryOptions<TId> & {
-		readonly versionColumn: VersionColumn<TModel, TId>;
+		readonly versionColumn: TVersion;
 		readonly conflictColumns?: never;
 		readonly conflictWhere?: never;
 	},
-): Effect.Effect<VersionedRepository<TModel, TId>, BucketRegistrationError, SqlClient.SqlClient>;
+): Effect.Effect<VersionedRepositoryShape<TModel, TId, TVersion>, BucketRegistrationError, SqlClient.SqlClient>;
 export function makeRepository<
 	TModel extends Model.Any,
 	const TId extends PrimaryKey<TModel>,

package/src/repositoryQueries.ts

@@ -1,14 +1,17 @@
-import { Effect, Schema } from "effect";
+import { Array as Arr, Effect, type Option, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import type { Fragment } from "effect/sql/Statement";
+import { groupColumns } from "#adapters/groupColumns.ts";
+import { storageSchema } from "#adapters/storageSchema.ts";
 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 type { FindMany, FindOne, LatestPerGroup } from "#repository.ts";
 import { makeFilter } from "#repositoryFilter.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.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"]>;
@@ -32,6 +35,13 @@ export interface Queries<TModel extends Model.Any> {
 		SqlError | Schema.SchemaError,
 		TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][TKey]["DecodingServices"]
 	>;
+	findOne: <TKey extends Key<TModel> = Key<TModel>>(
+		query?: FindOne<TModel, TKey>,
+	) => Effect.Effect<
+		Option.Option<Pick<Row<TModel>, TKey>>,
+		SqlError | Schema.SchemaError,
+		TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][TKey]["DecodingServices"]
+	>;
 	latestPerGroup: (
 		query: LatestPerGroup<TModel>,
 	) => Effect.Effect<
@@ -53,6 +63,7 @@ export function makeQueries<TModel extends Model.Any>(
 ): Effect.Effect<Queries<TModel>, never, SqlClient.SqlClient> {
 	return Effect.fnUntraced(function* () {
 		const sql = yield* SqlClient.SqlClient;
+		const nameTransforms = yield* sqlNameTransforms;
 		const { fieldAt, where } = yield* makeFilter(model);
 		const readLatest = yield* makeLatestPerGroup(model, options.tableName);
 		const { decodeLimit, orderClause, limitClause } = yield* makeQueryClauses(fieldAt);
@@ -77,7 +88,7 @@ export function makeQueries<TModel extends Model.Any>(
 				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 sql`select ${sql.csv(groupColumns(model.fields, keys).map(({ column }) => sql`${sql(column)}`))} from ${sql(options.tableName)} where ${predicate} ${order} ${limit}`;
 			});
 			return { fields, statement };
 		}
@@ -93,7 +104,7 @@ export function makeQueries<TModel extends Model.Any>(
 			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);
+				return yield* Schema.decodeUnknownEffect(Schema.Array(storageSchema(Schema.Struct(selected.fields), selected.fields, nameTransforms)))(rows);
 			}).pipe(Effect.withSpan(`${options.spanPrefix}.findMany`));
 		}
 		function latestPerGroup(query: LatestPerGroup<TModel>): ReturnType<Queries<TModel>["latestPerGroup"]>;
@@ -104,6 +115,8 @@ export function makeQueries<TModel extends Model.Any>(
 				return yield* readLatest(query, order, rowLimit);
 			}).pipe(Effect.withSpan(`${options.spanPrefix}.latestPerGroup`));
 		}
-		return { aggregate, count, findMany, latestPerGroup, select };
+		const findOne: Queries<TModel>["findOne"] = (query = {}) =>
+			findMany({ ...query, limit: 1 }).pipe(Effect.map(Arr.head), Effect.withSpan(`${options.spanPrefix}.findOne`));
+		return { aggregate, count, findMany, findOne, latestPerGroup, select };
 	})();
 }

package/src/repositoryUpdate.ts

@@ -8,11 +8,11 @@ export type UpdateInput<TModel extends Model.Any> = {
 	readonly [TKey in keyof TModel["update"]["Type"]]: WithoutOverride<TModel["update"]["Type"][TKey]>;
 };
 
-type Column<TModel extends Model.Any, TId extends PropertyKey> = Exclude<Extract<keyof UpdateInput<TModel>, string>, TId>;
-type Selected<TModel extends Model.Any, TId extends PropertyKey, TColumn extends PropertyKey> = Required<
+export type Column<TModel extends Model.Any, TId extends PropertyKey> = Exclude<Extract<keyof UpdateInput<TModel>, string>, TId>;
+export type Selected<TModel extends Model.Any, TId extends PropertyKey, TColumn extends PropertyKey> = Required<
 	Pick<UpdateInput<TModel>, Extract<TId | TColumn, keyof UpdateInput<TModel>>>
 >;
-interface Columns<TColumn> {
+export interface Columns<TColumn> {
 	readonly columns: readonly [TColumn, ...TColumn[]];
 }
 type WriteResult<TModel extends Model.Any, A, E = never> = Effect.Effect<

package/src/repositoryWrites.ts

@@ -1,9 +1,11 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient, SqlSchema } from "effect/sql";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
 import { makeFilter } from "#repositoryFilter.ts";
 import { selectedUpdate } from "#repositoryUpdate.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 
 export const repositoryWrites = Effect.fnUntraced(function* (
 	model: Model.Any,
@@ -11,6 +13,7 @@ export const repositoryWrites = Effect.fnUntraced(function* (
 	changes: RepositoryChanges,
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { idColumns, tableName, spanPrefix } = options;
 	const { where } = yield* makeFilter(model);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
@@ -33,17 +36,29 @@ export const repositoryWrites = Effect.fnUntraced(function* (
 			),
 		);
 	}
-	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 insertRow = SqlSchema.findOne({
+		execute: insert,
+		Request: storageSchema(model.insert, model.fields, nameTransforms),
+		Result: storageSchema(model, model.fields, nameTransforms),
+	});
+	const insertVoid = SqlSchema.void({ execute: insert, Request: storageSchema(model.insert, model.fields, nameTransforms) });
+	const updateRow = SqlSchema.findOne({
+		execute: update,
+		Request: storageSchema(model.update, model.fields, nameTransforms),
+		Result: storageSchema(model, model.fields, nameTransforms),
+	});
+	const updateVoid = SqlSchema.void({ execute: update, Request: storageSchema(model.update, model.fields, nameTransforms) });
 	function selected(input: unknown, columns: readonly string[], returning: boolean) {
 		return Effect.gen(function* () {
 			const row = yield* record(input);
 			const Request = yield* selectedUpdate(model, columns, idColumns, row);
 			return yield* returning
-				? SqlSchema.findOne({ execute: update, Request, Result: model })(row)
-				: SqlSchema.void({ execute: update, Request })(row);
+				? SqlSchema.findOne({
+						execute: update,
+						Request: storageSchema(Request, model.fields, nameTransforms),
+						Result: storageSchema(model, model.fields, nameTransforms),
+					})(row)
+				: SqlSchema.void({ execute: update, Request: storageSchema(Request, model.fields, nameTransforms) })(row);
 		});
 	}
 	const idColumn = idColumns[0] ?? "";

package/src/setWorkerReleaseActive.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import type { initializeWorkerRelease } from "./initializeWorkerRelease.ts";
+
+export function setWorkerReleaseActive(state: Effect.Success<typeof initializeWorkerRelease>) {
+	return (next: boolean) =>
+		state
+			.locked(
+				Effect.gen(function* () {
+					if (next === state.active) {
+						return;
+					}
+					state.active = next;
+					yield* Effect.forEach(state.controls, (control) => control(state.active), { concurrency: "unbounded", discard: true });
+				}),
+			)
+			.pipe(Effect.uninterruptible);
+}

package/src/sqlNameTransforms.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import type { SqlNameTransforms } from "#clientOptions.ts";
+
+export const sqlNameTransforms = Effect.gen(function* () {
+	const client = yield* SqlClient.SqlClient;
+	const namedClient: SqlClient.SqlClient & { readonly config?: SqlNameTransforms } = client;
+	return namedClient.config;
+});

package/src/upsertResult.ts

@@ -1,6 +1,8 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
+import { storageSchema } from "#adapters/storageSchema.ts";
+import type { SqlNameTransforms } from "#clientOptions.ts";
 
 export interface UpsertRow<TRow> {
 	readonly inserted: boolean;
@@ -12,8 +14,8 @@ export const upsertReturning = Effect.fnUntraced(function* () {
 	return sql`*, (xmax = 0) as ${sql("effectSqlInserted")}`;
 });
 
-export function makeUpsertDecoder(model: Model.Any) {
-	const decode = Schema.decodeUnknownEffect(model);
+export function makeUpsertDecoder(model: Model.Any, names?: SqlNameTransforms) {
+	const decode = Schema.decodeUnknownEffect(storageSchema(model, model.fields, names));
 	return (row: Readonly<Record<string, unknown>> | undefined) =>
 		Effect.map(decode(row), (decoded) => ({ inserted: row?.effectSqlInserted === true, row: decoded }));
 }

package/src/versionedRepository.ts

@@ -2,10 +2,12 @@ import { Effect, Option, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient, type SqlModel } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import type { PrimaryKey, Repository } from "#compositeRepository.ts";
 import type { OptimisticConcurrencyError } from "#repository.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
-import type { UpdateInput } from "#repositoryUpdate.ts";
+import type { Column, Columns, Selected, UpdateInput } from "#repositoryUpdate.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import { type VersionedOptions, versionedStatements } from "#versionedStatements.ts";
 
 export type IdColumn<TModel extends Model.Any> = keyof TModel["Type"] & keyof TModel["update"]["Type"] & keyof TModel["fields"];
@@ -30,17 +32,34 @@ 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>> {
+type RequiredColumn<TModel extends Model.Any, TId extends PrimaryKey<TModel>, TVersion extends PropertyKey> = KeyColumn<TModel, TId> | TVersion;
+interface VersionedUpdate<
+	TModel extends Model.Any,
+	TId extends PrimaryKey<TModel>,
+	TVersion extends VersionColumn<TModel, TId>,
+	A,
+	R = TModel["update"]["EncodingServices"] | TModel["DecodingServices"],
+> {
+	<TColumn extends Column<TModel, RequiredColumn<TModel, TId, TVersion>>>(
+		input: Selected<TModel, RequiredColumn<TModel, TId, TVersion>, TColumn>,
+		options: Columns<TColumn>,
+	): Effect.Effect<A, WriteError, R>;
+	(input: UpdateInput<TModel>): Effect.Effect<A, WriteError, R>;
+}
+
+export interface VersionedWrites<
+	TModel extends Model.Any,
+	TId extends PrimaryKey<TModel>,
+	TVersion extends VersionColumn<TModel, TId> = VersionColumn<TModel, TId>,
+> {
 	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: UpdateInput<TModel>,
-	) => Effect.Effect<TModel["Type"], WriteError, TModel["update"]["EncodingServices"] | TModel["DecodingServices"]>;
-	readonly updateVoid: (input: UpdateInput<TModel>) => Effect.Effect<void, WriteError, TModel["update"]["EncodingServices"]>;
+	readonly update: VersionedUpdate<TModel, TId, TVersion, TModel["Type"]>;
+	readonly updateVoid: VersionedUpdate<TModel, TId, TVersion, void, TModel["update"]["EncodingServices"]>;
 }
 
 export const makeVersionedWrites = Effect.fnUntraced(function* (
@@ -48,9 +67,10 @@ export const makeVersionedWrites = Effect.fnUntraced(function* (
 	options: VersionedOptions & { readonly changes: RepositoryChanges; readonly spanPrefix: string },
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { spanPrefix, changes } = options;
 	const statements = yield* versionedStatements(model, options);
-	const decodeRow = Schema.decodeUnknownEffect(model);
+	const decodeRow = Schema.decodeUnknownEffect(storageSchema(model, model.fields, nameTransforms));
 	function insert(input: unknown) {
 		return Effect.gen(function* () {
 			const statement = yield* statements.insert(input);
@@ -74,9 +94,9 @@ export const makeVersionedWrites = Effect.fnUntraced(function* (
 			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>>) {
+	function update(input: Readonly<Record<string, unknown>>, settings?: { readonly columns: readonly string[] }) {
 		return Effect.gen(function* () {
-			const { statement, classify } = yield* statements.update(input);
+			const { statement, classify } = yield* statements.update(input, settings?.columns);
 			const rows = yield* sql`${statement} returning ${changes.returning()}`;
 			if (rows.length === 0) {
 				return yield* classify();
@@ -85,9 +105,9 @@ export const makeVersionedWrites = Effect.fnUntraced(function* (
 			return yield* decodeRow(rows[0]);
 		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.update`));
 	}
-	function updateVoid(input: Readonly<Record<string, unknown>>) {
+	function updateVoid(input: Readonly<Record<string, unknown>>, settings?: { readonly columns: readonly string[] }) {
 		return Effect.gen(function* () {
-			const { statement, classify } = yield* statements.update(input);
+			const { statement, classify } = yield* statements.update(input, settings?.columns);
 			const rows = yield* sql`${statement} returning ${changes.returning()}`;
 			if (rows.length === 0) {
 				return yield* classify();

package/src/versionedStatements.ts

@@ -1,8 +1,11 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import { makeConflictClause } from "#makeConflictClause.ts";
 import type { OptimisticConcurrencyError } from "#repository.ts";
+import { selectedUpdate } from "#repositoryUpdate.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 
 const Version = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
 export interface VersionedOptions {
@@ -16,6 +19,7 @@ export interface VersionedOptions {
 
 export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any, options: VersionedOptions) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { tableName, idColumns, versionColumn, conflict } = options;
 	const entries: [string, Schema.Constraint][] = [];
 	for (const column of idColumns) {
@@ -31,8 +35,8 @@ export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any
 		return yield* Effect.die(new Error(`Unknown version column: ${versionColumn}`));
 	}
 	const encodeVersion = Schema.encodeEffect(versionSchema);
-	const encodeInsert = Schema.encodeEffect(model.insert);
-	const encodeUpdate = Schema.encodeEffect(model.update);
+	const encodeInsert = Schema.encodeEffect(storageSchema(model.insert, model.fields, nameTransforms));
+	const encodeUpdate = Schema.encodeEffect(storageSchema(model.update, model.fields, nameTransforms));
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const validateVersion = Schema.decodeUnknownEffect(Version);
 	const clause =
@@ -59,9 +63,15 @@ export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any
 			return sql`insert into ${sql(tableName)} ${sql.insert(encoded)} ${suffix}`;
 		});
 	}
-	function update(input: Readonly<Record<string, unknown>>) {
+	function update(input: Readonly<Record<string, unknown>>, columns?: readonly string[]) {
 		return Effect.gen(function* () {
-			const encoded = yield* record(yield* encodeUpdate(input));
+			const encoded = yield* record(
+				yield* columns === undefined
+					? encodeUpdate(input)
+					: Effect.flatMap(selectedUpdate(model, columns, [...idColumns, versionColumn], input), (schema) =>
+							Schema.encodeEffect(storageSchema(schema, model.fields, nameTransforms))(input),
+						),
+			);
 			const expectedVersion = yield* validateVersion(encoded[versionColumn]);
 			const assignments = Object.entries(encoded).filter(([column]) => !idColumns.includes(column) && column !== versionColumn);
 			const set = sql.csv([