@shivaedev/sql 0.36.1 → 0.38.0

package/src/WorkerRelease.ts

@@ -1,40 +1,11 @@
-import { Effect, Semaphore } from "effect";
 import { defineService } from "@shivaedev/service/defineService.ts";
 import { genericMethod } from "@shivaedev/service/genericMethod.ts";
-
-export const makeWorkerRelease = Effect.fn("EffectSql.makeWorkerRelease")(function* () {
-	const mutex = Semaphore.makeUnsafe(1);
-	const controls = new Set<(active: boolean) => Effect.Effect<void, unknown>>();
-	let active = false;
-	const locked = mutex.withPermits(1);
-	function register<E>(control: (active: boolean) => Effect.Effect<void, E>) {
-		const attach = Effect.gen(function* () {
-			controls.add(control);
-			yield* control(active);
-		});
-		const detach = Effect.sync(() => {
-			controls.delete(control);
-		});
-		return Effect.acquireRelease(locked(attach), () => locked(detach));
-	}
-	return {
-		service: { register },
-		setActive: (next: boolean) =>
-			locked(
-				Effect.gen(function* () {
-					if (next === active) {
-						return;
-					}
-					active = next;
-					yield* Effect.forEach(controls, (control) => control(active), { concurrency: "unbounded", discard: true });
-				}),
-			).pipe(Effect.uninterruptible),
-	};
-});
+import { initializeWorkerRelease } from "./initializeWorkerRelease.ts";
+import { registerWorkerRelease } from "./registerWorkerRelease.ts";
 
 export const WorkerRelease = defineService({
 	id: "@shivaedev/sql/WorkerRelease",
-	initialize: makeWorkerRelease(),
-	methods: ({ service }) => ({ register: genericMethod(service.register) }),
+	initialize: initializeWorkerRelease,
+	methods: (state) => ({ register: genericMethod(registerWorkerRelease(state)) }),
 	requires: [],
 });

package/src/adapters/groupColumns.ts

@@ -0,0 +1,63 @@
+import type { Schema } from "effect";
+import { Predicate, SchemaAST } from "effect";
+import type { SqlNameTransforms } from "#clientOptions.ts";
+
+interface Column {
+	readonly column: string;
+	readonly key: string;
+	readonly member: PropertyKey | undefined;
+}
+
+export function groupColumns(fields: Schema.Struct.Fields, keys: readonly string[] = Object.keys(fields)): Column[] {
+	return keys.flatMap<Column>((key) => {
+		const ast = fields[key]?.ast;
+		const prefix = ast?.annotations?.["@shivaedev/sql/groupPrefix"];
+		return typeof prefix === "string" && ast !== undefined && SchemaAST.isObjects(ast)
+			? ast.propertySignatures.map((field) => ({ column: `${prefix}${String(field.name)}`, key, member: field.name }))
+			: [{ column: key, key, member: undefined }];
+	});
+}
+
+export function rowMapping(fields: Schema.Struct.Fields, names?: SqlNameTransforms) {
+	const columns = groupColumns(fields);
+	function returnedName(column: string) {
+		return names?.transformResultNames?.(names.transformQueryNames?.(column) ?? column) ?? column;
+	}
+	const seen = new Set<string>();
+	for (const { column } of columns) {
+		if (seen.has(column)) {
+			throw new Error(`Duplicate grouped column: ${column}`);
+		}
+		seen.add(column);
+	}
+	return {
+		expand: (row: Readonly<Record<string, unknown>>) => {
+			const expanded: Record<string, unknown> = { ...row };
+			for (const { key, member, column } of columns) {
+				if (member !== undefined && Object.hasOwn(row, returnedName(column))) {
+					const held = expanded[key];
+					expanded[key] = { ...(typeof held === "object" && held !== null ? held : {}), [member]: row[returnedName(column)] };
+					delete expanded[returnedName(column)];
+				}
+			}
+			return expanded;
+		},
+		flatten: (row: unknown) => {
+			if (!Predicate.isObject(row)) {
+				return {};
+			}
+			const flat: Record<string, unknown> = { ...row };
+			for (const { key, member, column } of columns) {
+				if (member === undefined) {
+					continue;
+				}
+				delete flat[key];
+				const value = row[key];
+				if (Predicate.isObject(value) && Object.hasOwn(value, member)) {
+					flat[column] = Reflect.get(value, member);
+				}
+			}
+			return flat;
+		},
+	};
+}

package/src/adapters/storageSchema.ts

@@ -0,0 +1,10 @@
+import { Schema, SchemaGetter } from "effect";
+import { rowMapping } from "#adapters/groupColumns.ts";
+import type { SqlNameTransforms } from "#clientOptions.ts";
+
+export function storageSchema<TSchema extends Schema.Constraint>(schema: TSchema, fields: Schema.Struct.Fields, names?: SqlNameTransforms) {
+	const mapping = rowMapping(fields, names);
+	return Schema.Record(Schema.String, Schema.Unknown).pipe(
+		Schema.decodeTo(schema, { decode: SchemaGetter.transform(mapping.expand), encode: SchemaGetter.transform(mapping.flatten) }),
+	);
+}

package/src/backfillPostgres.ts

@@ -0,0 +1,47 @@
+import { Data, Effect, Option, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { advisoryXactLock } from "#advisoryXactLock.ts";
+import { transact } from "#transact.ts";
+
+export class BackfillInsideTransaction extends Data.TaggedError("BackfillInsideTransaction") {}
+
+export interface BackfillOptions<TRow extends object, TProgress, E, R> {
+	readonly batchSize: number;
+	readonly loadProgress: Effect.Effect<TProgress, E, R>;
+	readonly lock: bigint | string;
+	readonly process: (row: TRow) => Effect.Effect<unknown, E, R>;
+	readonly saveProgress: (last: TRow, previous: TProgress) => Effect.Effect<unknown, E, R>;
+	readonly select: (progress: TProgress, limit: number) => Effect.Effect<readonly TRow[], E, R>;
+}
+
+const BatchSize = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+
+export const backfillPostgres = Effect.fn("Sql.backfillPostgres")(function* <TRow extends object, TProgress, E, R>(
+	options: BackfillOptions<TRow, TProgress, E, R>,
+) {
+	const sql = yield* SqlClient.SqlClient;
+	if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {
+		return yield* new BackfillInsideTransaction();
+	}
+	const batchSize = yield* Schema.decodeUnknownEffect(BatchSize)(options.batchSize);
+	let processed = 0;
+	while (true) {
+		const count = yield* Effect.gen(function* () {
+			yield* advisoryXactLock(options.lock).pipe(Effect.catchTag("AdvisoryLockOutsideTransaction", Effect.die));
+			const progress = yield* options.loadProgress;
+			const rows = (yield* options.select(progress, batchSize)).slice(0, batchSize);
+			for (const row of rows) {
+				yield* options.process(row);
+			}
+			const last = rows.at(-1);
+			if (last !== undefined) {
+				yield* options.saveProgress(last, progress);
+			}
+			return rows.length;
+		}).pipe(transact({ onSqlError: (error) => error }));
+		processed += count;
+		if (count === 0) {
+			return processed;
+		}
+	}
+});

package/src/batchWrites.ts

@@ -3,7 +3,9 @@ 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 { storageSchema } from "#adapters/storageSchema.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import { makeUpsertDecoder, upsertReturning } from "#upsertResult.ts";
 
 export type InsertMany<TModel extends Model.Any, TServices = never> = (
@@ -22,11 +24,12 @@ export const makeInsertMany = Effect.fnUntraced(function* <TServices = never>(
 	upsert = false,
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const prepareRow = prepare ?? (() => Effect.succeed(sql``));
-	const encode = Schema.encodeEffect(model.insert);
+	const encode = Schema.encodeEffect(storageSchema(model.insert, model.fields, nameTransforms));
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
-	const decode = Schema.decodeUnknownEffect(Schema.Array(model));
-	const decodeUpsert = makeUpsertDecoder(model);
+	const decode = Schema.decodeUnknownEffect(Schema.Array(storageSchema(model, model.fields, nameTransforms)));
+	const decodeUpsert = makeUpsertDecoder(model, nameTransforms);
 	const returning = options.changes.returning(upsert ? yield* upsertReturning() : sql`*`);
 	return (inputs: readonly unknown[]) =>
 		Effect.gen(function* () {

package/src/compositeRepository.ts

@@ -3,11 +3,13 @@ import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient, SqlSchema } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import type { BatchedDelete } from "#batchedDelete.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
 import type { RepositoryListFilter } from "#repositoryFilter.ts";
 import type { Update, UpdateVoid } from "#repositoryUpdate.ts";
 import { repositoryWrites } from "#repositoryWrites.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import type { IdColumn, NativeRepository } from "#versionedRepository.ts";
 
 export type CompositeKey<TModel extends Model.Any> = readonly [IdColumn<TModel>, IdColumn<TModel>, ...IdColumn<TModel>[]];
@@ -51,6 +53,7 @@ export const makeCompositeCrud = Effect.fnUntraced(function* (
 	changes: RepositoryChanges,
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { columns, tableName, spanPrefix } = options;
 	const entries: [string, Schema.Constraint][] = [];
 	for (const column of columns) {
@@ -76,7 +79,7 @@ export const makeCompositeCrud = Effect.fnUntraced(function* (
 				(key) => sql`select * from ${sql(tableName)} where ${predicate(key)}`,
 			),
 		Request: Key,
-		Result: model,
+		Result: storageSchema(model, model.fields, nameTransforms),
 	});
 
 	return {

package/src/conditionalUpsert.ts

@@ -2,9 +2,11 @@ import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import { makeConflictClause } from "#makeConflictClause.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
 import type { Comparisons, FindManyFilter } from "#repositoryFilter.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import type { UpsertAssignment } from "#upsertColumns.ts";
 import { makeUpsertDecoder, type UpsertRow, upsertReturning } from "#upsertResult.ts";
 
@@ -65,10 +67,11 @@ export const makeConditionalUpsert = Effect.fnUntraced(function* (
 	},
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const returning = yield* upsertReturning();
-	const encode = Schema.encodeEffect(model.insert);
+	const encode = Schema.encodeEffect(storageSchema(model.insert, model.fields, nameTransforms));
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
-	const decode = makeUpsertDecoder(model);
+	const decode = makeUpsertDecoder(model, nameTransforms);
 	const clause = yield* makeConflictClause(model, options);
 	return (
 		inputs: readonly unknown[],

package/src/conflictWrites.ts

@@ -2,11 +2,13 @@ import { Effect, Option, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import { type InsertMany, makeInsertMany } from "#batchWrites.ts";
 import { type ConditionalUpsert, type ConditionalUpsertMany, makeConditionalUpsert } from "#conditionalUpsert.ts";
 import { type InsertFromSelect, makeInsertFromSelect } from "#insertFromSelect.ts";
 import { makeConflictClause } from "#makeConflictClause.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import type { UpsertAssignment, UpsertColumn } from "#upsertColumns.ts";
 import { makeUpsertDecoder, upsertReturning } from "#upsertResult.ts";
 
@@ -52,11 +54,12 @@ export const makeConflictWrites = Effect.fnUntraced(function* (
 	},
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { tableName, spanPrefix } = options;
 	const returning = yield* upsertReturning();
-	const encode = Schema.encodeEffect(model.insert);
-	const decode = Schema.decodeUnknownEffect(model);
-	const decodeUpsert = makeUpsertDecoder(model);
+	const encode = Schema.encodeEffect(storageSchema(model.insert, model.fields, nameTransforms));
+	const decode = Schema.decodeUnknownEffect(storageSchema(model, model.fields, nameTransforms));
+	const decodeUpsert = makeUpsertDecoder(model, nameTransforms);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const conditional = yield* makeConditionalUpsert(model, options);
 	const clause = yield* makeConflictClause(model, options);

package/src/coordinateWorkerRelease.ts

@@ -1,9 +1,9 @@
 import { Duration, Effect, Exit, Option, Predicate, Schedule, Scope } from "effect";
 import { isSqlError } from "effect/sql/SqlError";
 import { WorkerReleaseTesting } from "#testing/WorkerRelease.ts";
+import { makeWorkerRelease } from "./makeWorkerRelease.ts";
 import { readPostgresRelease } from "./postgresRelease.ts";
 import { releaseWorkers } from "./releaseWorkers.ts";
-import { makeWorkerRelease } from "./WorkerRelease.ts";
 
 function isCloseable(scope: Scope.Scope): scope is Scope.Closeable {
 	return Predicate.hasProperty(scope, "~effect/Scope/Closeable") && scope["~effect/Scope/Closeable"] === "~effect/Scope/Closeable";

package/src/initializeWorkerRelease.ts

@@ -0,0 +1,7 @@
+import { Effect, Semaphore } from "effect";
+
+export const initializeWorkerRelease = Effect.sync(() => ({
+	active: false,
+	controls: new Set<(active: boolean) => Effect.Effect<void, unknown>>(),
+	locked: Semaphore.makeUnsafe(1).withPermits(1),
+}));

package/src/insertFromSelect.ts

@@ -3,8 +3,10 @@ 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 { storageSchema } from "#adapters/storageSchema.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
 import type { RepositorySelect } from "#repositoryQueries.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 
 type CompatibleColumn<TType, TEncoded, TFields extends Schema.Struct.Fields> = {
 	[TKey in keyof TFields]: TFields[TKey]["Type"] extends TType ? (TFields[TKey]["Encoded"] extends TEncoded ? TKey : never) : never;
@@ -31,7 +33,8 @@ export const makeInsertFromSelect = Effect.fnUntraced(function* <TServices = nev
 	prepare?: (columns: readonly string[]) => Effect.Effect<Fragment, SqlError | Schema.SchemaError, TServices>,
 ) {
 	const sql = yield* SqlClient.SqlClient;
-	const decode = Schema.decodeUnknownEffect(Schema.Array(model));
+	const nameTransforms = yield* sqlNameTransforms;
+	const decode = Schema.decodeUnknownEffect(Schema.Array(storageSchema(model, model.fields, nameTransforms)));
 	return (source: RepositorySelect<Schema.Struct.Fields, unknown>, columns: Readonly<Record<string, string>>) =>
 		Effect.gen(function* () {
 			const names = Object.keys(columns);

package/src/latestPerGroup.ts

@@ -2,9 +2,12 @@ import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
 import type { Fragment } from "effect/sql/Statement";
+import { groupColumns } from "#adapters/groupColumns.ts";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import { pinnedGroups } from "#pinnedGroups.ts";
 import type { LatestPerGroup } from "#repository.ts";
 import { makeFilter } from "#repositoryFilter.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import { tupleUnnest } from "#tupleUnnest.ts";
 
 function groupMasks(input: readonly (readonly unknown[])[]) {
@@ -20,6 +23,7 @@ function groupMasks(input: readonly (readonly unknown[])[]) {
 
 export const latestPerGroup = Effect.fnUntraced(function* (model: Model.Any, tableName: string) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { fieldAt, where } = yield* makeFilter(model);
 	function groupSource(groups: readonly (readonly unknown[])[], partitionBy: readonly string[], fromTuple: boolean) {
 		const partitions = sql.csv(partitionBy.map((key) => sql`${sql(key)}`));
@@ -37,7 +41,7 @@ export const latestPerGroup = Effect.fnUntraced(function* (model: Model.Any, tab
 		const predicate = yield* where(query.where, true);
 		const partitions = sql.csv(query.partitionBy.map((key) => sql`${sql(key)}`));
 		const keys = Object.keys(model.fields);
-		const columns = sql.csv(keys.map((key) => sql`${sql(key)}`));
+		const columns = sql.csv(groupColumns(model.fields, keys).map(({ column }) => sql`${sql(column)}`));
 		const pinned = yield* pinnedGroups(model, query.partitionBy, query.where).pipe(Effect.provideService(SqlClient.SqlClient, sql));
 		if (pinned !== undefined && pinned.groups.length === 0) {
 			return [];
@@ -70,7 +74,7 @@ export const latestPerGroup = Effect.fnUntraced(function* (model: Model.Any, tab
 			const ordering = sql.csv(query.orderBy.map(({ field, direction }) => sql`${sql(field)} ${sql.literal(direction === "desc" ? "desc" : "asc")}`));
 			const rows =
 				yield* sql`${tupleSource} select ${columns} from (${sql.join(" union all ")(branches)}) as ${sql("__effect_sql_pinned")} order by ${partitions}, ${ordering}`;
-			return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(model.fields)))(rows);
+			return yield* Schema.decodeUnknownEffect(Schema.Array(storageSchema(Schema.Struct(model.fields), model.fields, nameTransforms)))(rows);
 		}
 		let rankColumn = "__effect_sql_rank";
 		while (Object.hasOwn(model.fields, rankColumn)) {
@@ -81,6 +85,6 @@ export const latestPerGroup = Effect.fnUntraced(function* (model: Model.Any, tab
 			from ${sql(tableName)} where ${predicate}
 		) as ${sql("__effect_sql_ranked")} where ${sql(rankColumn)} <= ${rowLimit}
 		order by ${partitions}, ${sql(rankColumn)}`;
-		return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(model.fields)))(rows);
+		return yield* Schema.decodeUnknownEffect(Schema.Array(storageSchema(Schema.Struct(model.fields), model.fields, nameTransforms)))(rows);
 	});
 });

package/src/makeOrderedChildren.ts

@@ -0,0 +1,78 @@
+import { type Cause, Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import { SqlClient, SqlSchema } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import { storageSchema } from "#adapters/storageSchema.ts";
+import { type ChildOrderError, orderedChildStatements } from "#orderedChildStatements.ts";
+import { repositoryChanges } from "#repositoryChanges.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
+import type { IdColumn, VersionColumn } from "#versionedRepository.ts";
+
+type Column<TModel extends Model.Any> = Extract<keyof TModel["fields"] & keyof TModel["insert"]["Type"], string>;
+type Position<TModel extends Model.Any> = {
+	[TKey in Column<TModel>]: TModel["fields"][TKey] extends Schema.ConstraintCodec<number, number, never, never> ? TKey : never;
+}[Column<TModel>];
+
+export const makeOrderedChildren = Effect.fn("Sql.makeOrderedChildren")(function* <
+	TModel extends Model.Any,
+	const TId extends Extract<IdColumn<TModel>, string>,
+	const TParent extends Column<TModel>,
+	const TPosition extends Position<TModel>,
+>(
+	model: TModel,
+	options: {
+		readonly idColumn: TId;
+		readonly parentColumn: TParent;
+		readonly parentTable: string;
+		readonly parentIdColumn: string;
+		readonly positionColumn: TPosition;
+		readonly spanPrefix: string;
+		readonly tableName: string;
+		readonly versionColumn?: VersionColumn<TModel, TId>;
+	},
+) {
+	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
+	const changes = yield* repositoryChanges(options.tableName, [options.idColumn], model.fields);
+	const statements = yield* orderedChildStatements(model, options, changes);
+	const encode = Schema.encodeEffect(storageSchema(model.insert, model.fields, nameTransforms));
+	const decode = Schema.decodeUnknownEffect(storageSchema(model, model.fields, nameTransforms));
+	const { parentColumn, positionColumn, versionColumn, tableName, spanPrefix } = options;
+	function append(
+		parent: TModel["fields"][TParent]["Type"],
+		input: Omit<TModel["insert"]["Type"], TParent | TPosition>,
+	): Effect.Effect<
+		TModel["Type"],
+		SqlError | Schema.SchemaError | Cause.NoSuchElementError,
+		TModel["insert"]["EncodingServices"] | TModel["DecodingServices"]
+	> {
+		return Effect.gen(function* () {
+			const encodedParent = yield* statements.lock(parent);
+			const last = yield* SqlSchema.findOne({
+				execute: (value) =>
+					sql`select coalesce(max(${sql(positionColumn)}) + 1, 0)::integer as next from ${sql(tableName)} where ${sql(parentColumn)} = ${value}`,
+				Request: Schema.Unknown,
+				Result: Schema.Struct({ next: Schema.Int }),
+			})(encodedParent);
+			const encoded = yield* encode({ ...input, [parentColumn]: parent, [positionColumn]: last.next });
+			const row = versionColumn === undefined ? encoded : { ...encoded, [versionColumn]: 0 };
+			const rows = yield* sql`insert into ${sql(tableName)} ${sql.insert(row)} returning ${changes.returning()}`;
+			yield* changes.record(rows);
+			return yield* decode(rows[0]);
+		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.append`));
+	}
+	type OrderResult = Effect.Effect<
+		void,
+		SqlError | Schema.SchemaError | Cause.NoSuchElementError | ChildOrderError,
+		TModel["fields"][TParent | TId]["EncodingServices"] | TModel["fields"][TId]["DecodingServices"]
+	>;
+	function move(parent: TModel["fields"][TParent]["Type"], id: TModel["fields"][TId]["Type"], position: number): OrderResult;
+	function move(parent: unknown, id: unknown, position: number) {
+		return statements.move(parent, id, position).pipe(changes.write, Effect.withSpan(`${spanPrefix}.move`));
+	}
+	function reorder(parent: TModel["fields"][TParent]["Type"], ids: readonly TModel["fields"][TId]["Type"][]): OrderResult;
+	function reorder(parent: unknown, ids: readonly unknown[]) {
+		return statements.reorder(parent, ids).pipe(changes.write, Effect.withSpan(`${spanPrefix}.reorder`));
+	}
+	return { append, move, reorder };
+});

package/src/makeWorkerRelease.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { initializeWorkerRelease } from "./initializeWorkerRelease.ts";
+import { registerWorkerRelease } from "./registerWorkerRelease.ts";
+import { setWorkerReleaseActive } from "./setWorkerReleaseActive.ts";
+
+export const makeWorkerRelease = Effect.fn("EffectSql.makeWorkerRelease")(function* () {
+	const state = yield* initializeWorkerRelease;
+	return {
+		service: { register: registerWorkerRelease(state) },
+		setActive: setWorkerReleaseActive(state),
+	};
+});

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"]>;
@@ -41,39 +42,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>,