@shivaedev/sql 0.28.0 → 0.30.0

package/src/repository.ts

@@ -1,11 +1,13 @@
 import { Data, Effect, type Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
+import { makeBatchedDelete } from "#batchedDelete.ts";
 import { type BatchWrites, makeInsertMany } from "#batchWrites.ts";
 import { makeCompositeCrud, type PrimaryKey, type Repository } from "#compositeRepository.ts";
 import { type ConflictColumns, type ConflictWrites, makeConflictWrites } from "#conflictWrites.ts";
 import { makeInsertFromSelect, type SelectWrites } from "#insertFromSelect.ts";
 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";
@@ -39,12 +41,6 @@ export class OptimisticConcurrencyError extends Data.TaggedError("OptimisticConc
 	readonly reason: "missing" | "stale";
 }> {}
 
-interface RepositoryOptions<TId> {
-	readonly idColumn: TId;
-	readonly spanPrefix: string;
-	readonly tableName: string;
-}
-
 type VersionedRepository<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = Omit<
 	Repository<TModel, TId>,
 	keyof VersionedWrites<TModel, TId>
@@ -67,7 +63,7 @@ export function makeRepository<
 ): Effect.Effect<
 	VersionedRepository<TModel, TId> &
 		Pick<ConflictWrites<TModel, never, TModel["fields"][Extract<TWhere, keyof TModel["fields"]>]["EncodingServices"]>, "insertOrIgnore">,
-	never,
+	BucketRegistrationError,
 	SqlClient.SqlClient
 >;
 export function makeRepository<TModel extends Model.Any, const TId extends PrimaryKey<TModel>>(
@@ -77,7 +73,7 @@ export function makeRepository<TModel extends Model.Any, const TId extends Prima
 		readonly conflictColumns?: never;
 		readonly conflictWhere?: never;
 	},
-): Effect.Effect<VersionedRepository<TModel, TId>, never, SqlClient.SqlClient>;
+): Effect.Effect<VersionedRepository<TModel, TId>, BucketRegistrationError, SqlClient.SqlClient>;
 export function makeRepository<
 	TModel extends Model.Any,
 	const TId extends PrimaryKey<TModel>,
@@ -100,13 +96,17 @@ export function makeRepository<
 			TConflict[number] | (TId extends readonly PropertyKey[] ? TId[number] : TId),
 			TModel["fields"][Extract<TWhere, keyof TModel["fields"]>]["EncodingServices"]
 		>,
-	never,
+	BucketRegistrationError,
 	SqlClient.SqlClient
 >;
 export function makeRepository<TModel extends Model.Any, const TId extends PrimaryKey<TModel>>(
 	model: TModel,
 	options: RepositoryOptions<TId> & { readonly versionColumn?: never; readonly conflictColumns?: never; readonly conflictWhere?: never },
-): Effect.Effect<Repository<TModel, TId> & BatchWrites<TModel> & SelectWrites<TModel> & Queries<TModel>, never, SqlClient.SqlClient>;
+): Effect.Effect<
+	Repository<TModel, TId> & BatchWrites<TModel> & SelectWrites<TModel> & Queries<TModel>,
+	BucketRegistrationError,
+	SqlClient.SqlClient
+>;
 export function makeRepository<TModel extends Model.Any, TId extends IdColumn<TModel>>(
 	model: TModel,
 	options: RepositoryOptions<TId | readonly [TId, TId, ...TId[]]> & {
@@ -114,34 +114,36 @@ export function makeRepository<TModel extends Model.Any, TId extends IdColumn<TM
 		readonly conflictColumns?: readonly string[];
 		readonly conflictWhere?: Readonly<Record<string, unknown>>;
 	},
-): Effect.Effect<unknown, never, SqlClient.SqlClient> {
+): Effect.Effect<unknown, BucketRegistrationError, SqlClient.SqlClient> {
 	return Effect.fnUntraced(function* () {
+		yield* validateRepositoryCollection(model.fields, options);
 		const sql = yield* SqlClient.SqlClient;
 		const composite = typeof options.idColumn === "object";
 		const idColumns = (composite ? options.idColumn : [options.idColumn]).map(String);
 		const changes = yield* repositoryChanges(sql, options.tableName, idColumns, model.fields);
-		const crud = makeCompositeCrud(model, sql, { ...options, columns: idColumns }, changes);
+		const crud = {
+			...makeCompositeCrud(model, sql, { ...options, columns: idColumns }, changes),
+			deleteBatched: yield* makeBatchedDelete(model, options, changes),
+		};
 		const queries = makeQueries(model, sql, options);
-		return options.versionColumn === undefined
-			? {
-					...crud,
-					insertFromSelect: makeInsertFromSelect(model, sql, { ...options, changes }, "insertFromSelect"),
-					insertMany: makeInsertMany(model, sql, { ...options, changes }, "insertMany"),
-					...(options.conflictColumns === undefined
-						? {}
-						: makeConflictWrites(model, sql, { ...options, changes, conflictColumns: options.conflictColumns, idColumns })),
-					...queries,
-				}
-			: {
-					...crud,
-					...makeVersionedWrites(model, sql, {
+		return {
+			...crud,
+			...queries,
+			...(options.versionColumn === undefined
+				? {
+						insertFromSelect: makeInsertFromSelect(model, sql, { ...options, changes }, "insertFromSelect"),
+						insertMany: makeInsertMany(model, sql, { ...options, changes }, "insertMany"),
+						...(options.conflictColumns === undefined
+							? {}
+							: makeConflictWrites(model, sql, { ...options, changes, conflictColumns: options.conflictColumns, idColumns })),
+					}
+				: makeVersionedWrites(model, sql, {
 						...options,
 						changes,
 						conflict: (id, expectedVersion, reason) => new OptimisticConcurrencyError({ expectedVersion, id, reason, tableName: options.tableName }),
 						idColumns,
 						versionColumn: options.versionColumn,
-					}),
-					...queries,
-				};
+					})),
+		};
 	})();
 }

package/src/repositoryChanges.ts

@@ -66,5 +66,13 @@ export const repositoryChanges = Effect.fnUntraced(function* (
 	function write<A, E, R>(effect: Effect.Effect<A, E, R>) {
 		return provide(transact(effect, { onSqlError: (error) => error }));
 	}
-	return { record, returning, write };
+	const recordTable = Effect.fnUntraced(function* (rows: number) {
+		if (rows === 0) {
+			return;
+		}
+		const declarations = yield* ChangeDeclarations;
+		yield* declarations.declare(table, [table], rows);
+		yield* provide(invalidateOnCommit([table]));
+	});
+	return { record, recordTable, returning, write };
 });

package/src/repositoryCollection.ts

@@ -0,0 +1,46 @@
+import { Data, Effect, Order, type Schema } from "effect";
+import { declaredBuckets } from "@shivaedev/changes/buckets.ts";
+
+export interface RepositoryCollection {
+	readonly bucket: Readonly<Record<string, unknown>>;
+	readonly name: string;
+}
+
+export interface RepositoryOptions<TId> {
+	readonly collection?: RepositoryCollection;
+	readonly idColumn: TId;
+	readonly spanPrefix: string;
+	readonly tableName: string;
+}
+
+export class BucketRegistrationError extends Data.TaggedError("BucketRegistrationError")<{
+	readonly tableName: string;
+	readonly collectionName: string | undefined;
+	readonly modelFields: readonly string[];
+	readonly collectionFields: readonly string[];
+}> {
+	override get message() {
+		return `Bucket registration for ${this.tableName}: model fields ${JSON.stringify(this.modelFields)} disagree with collection ${this.collectionName ?? "(missing)"} fields ${JSON.stringify(this.collectionFields)}`;
+	}
+}
+
+export const validateRepositoryCollection = Effect.fnUntraced(function* (
+	fields: Schema.Struct.Fields,
+	options: { readonly tableName: string; readonly collection?: RepositoryCollection },
+) {
+	const modelFields = declaredBuckets(fields)
+		.map(({ field }) => field)
+		.sort(Order.String);
+	const collectionFields = Object.keys(options.collection?.bucket ?? {}).sort(Order.String);
+	if (
+		(options.collection === undefined && modelFields.length === 0)
+		|| (options.collection?.name === options.tableName
+			&& modelFields.length === collectionFields.length
+			&& modelFields.every((field, index) => field === collectionFields[index]))
+	) {
+		return;
+	}
+	return yield* Effect.fail(
+		new BucketRegistrationError({ collectionFields, collectionName: options.collection?.name, modelFields, tableName: options.tableName }),
+	);
+});

package/src/repositoryUpdate.ts

@@ -0,0 +1,65 @@
+import type { Brand, Cause } from "effect";
+import { Effect, Schema, SchemaAST, SchemaIssue } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlError } from "effect/sql/SqlError";
+
+type WithoutOverride<A> = A extends infer TValue & Brand.Brand<"Override"> ? TValue : A;
+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<
+	Pick<UpdateInput<TModel>, Extract<TId | TColumn, keyof UpdateInput<TModel>>>
+>;
+interface Columns<TColumn> {
+	readonly columns: readonly [TColumn, ...TColumn[]];
+}
+type WriteResult<TModel extends Model.Any, A, E = never> = Effect.Effect<
+	A,
+	SqlError | Schema.SchemaError | E,
+	TModel["update"]["EncodingServices"] | TModel["DecodingServices"]
+>;
+
+export interface Update<TModel extends Model.Any, TId extends PropertyKey> {
+	<TColumn extends Column<TModel, TId>>(
+		input: Selected<TModel, TId, TColumn>,
+		options: Columns<TColumn> & { readonly onMissing: "fail" },
+	): WriteResult<TModel, TModel["Type"], Cause.NoSuchElementError>;
+	<TColumn extends Column<TModel, TId>>(input: Selected<TModel, TId, TColumn>, options: Columns<TColumn>): WriteResult<TModel, TModel["Type"]>;
+	(input: UpdateInput<TModel>, options: { readonly onMissing: "fail" }): WriteResult<TModel, TModel["Type"], Cause.NoSuchElementError>;
+	(input: UpdateInput<TModel>): WriteResult<TModel, TModel["Type"]>;
+}
+
+export interface UpdateVoid<TModel extends Model.Any, TId extends PropertyKey> {
+	<TColumn extends Column<TModel, TId>>(
+		input: Selected<TModel, TId, TColumn>,
+		options: Columns<TColumn>,
+	): Effect.Effect<void, SqlError | Schema.SchemaError, TModel["update"]["EncodingServices"]>;
+	(input: UpdateInput<TModel>): Effect.Effect<void, SqlError | Schema.SchemaError, TModel["update"]["EncodingServices"]>;
+}
+
+export const selectedUpdate = Effect.fnUntraced(function* (
+	model: Model.Any,
+	columns: readonly string[],
+	idColumns: readonly string[],
+	input: Readonly<Record<string, unknown>>,
+) {
+	const ast = model.update.ast;
+	const fields = SchemaAST.isObjects(ast) ? ast.propertySignatures : [];
+	const writable = new Set(fields.map((field) => String(field.name)));
+	const invalid = columns.find((column) => idColumns.includes(column) || !writable.has(column));
+	if (columns.length === 0 || invalid !== undefined) {
+		return yield* Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([invalid ?? ""], new SchemaIssue.UnexpectedKey(ast, invalid ?? ""))));
+	}
+	const missing = [...idColumns, ...columns].find((column) => !Object.hasOwn(input, column));
+	if (missing !== undefined) {
+		return yield* Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([missing], new SchemaIssue.MissingKey(undefined))));
+	}
+	return Schema.make(
+		new SchemaAST.Objects(
+			fields.filter((field) => [...idColumns, ...columns].includes(String(field.name))),
+			[],
+		),
+	);
+});

package/src/repositoryWrites.ts

@@ -3,6 +3,7 @@ import type { Model } from "effect/schema";
 import { type SqlClient, SqlSchema } from "effect/sql";
 import type { RepositoryChanges } from "./repositoryChanges.ts";
 import { makeFilter } from "./repositoryFilter.ts";
+import { selectedUpdate } from "./repositoryUpdate.ts";
 
 export function repositoryWrites(
 	model: Model.Any,
@@ -36,6 +37,15 @@ export function repositoryWrites(
 	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 });
+	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);
+		});
+	}
 	const idColumn = idColumns[0] ?? "";
 	const key = model.fields[idColumn];
 	if (key === undefined) {
@@ -63,10 +73,15 @@ export function repositoryWrites(
 		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" }) =>
+		update: (input: unknown, settings?: { readonly onMissing?: "fail"; readonly columns?: readonly string[] }) => {
+			const result = settings?.columns === undefined ? updateRow(input) : selected(input, settings.columns, true);
+			return changes
+				.write(settings?.onMissing === "fail" ? result : result.pipe(Effect.catchTag("NoSuchElementError", Effect.die)))
+				.pipe(Effect.withSpan(`${spanPrefix}.update`));
+		},
+		updateVoid: (input: unknown, settings?: { readonly columns: readonly string[] }) =>
 			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`)),
+				.write(settings === undefined ? updateVoid(input) : selected(input, settings.columns, false))
+				.pipe(Effect.withSpan(`${spanPrefix}.updateVoid`)),
 	};
 }

package/src/testing.ts

@@ -76,8 +76,12 @@ export class PublishedKeysMismatch extends Data.TaggedError("PublishedKeysMismat
 	}
 }
 
-export function expectPublished(keys: readonly unknown[]) {
-	return Effect.fn("Changes.expectPublished")(function* <A, E, R>(body: Effect.Effect<A, E, R>) {
+export function expectPublished(keys: readonly unknown[]): <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | PublishedKeysMismatch, R>;
+export function expectPublished<A>(
+	keys: (result: A) => readonly unknown[],
+): <E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | PublishedKeysMismatch, R>;
+export function expectPublished<A>(keys: readonly unknown[] | ((result: A) => readonly unknown[])) {
+	return Effect.fn("Changes.expectPublished")(function* <E, R>(body: Effect.Effect<A, E, R>) {
 		const observer = yield* ChangeObserver;
 		const actual = new Set<unknown>();
 		const result = yield* body.pipe(
@@ -90,7 +94,7 @@ export function expectPublished(keys: readonly unknown[]) {
 				return observer(event);
 			}),
 		);
-		const expected = new Set(keys);
+		const expected = new Set(typeof keys === "function" ? keys(result) : keys);
 		if (actual.size !== expected.size || [...expected].some((key) => !actual.has(key))) {
 			return yield* Effect.fail(new PublishedKeysMismatch({ actual: [...actual], expected: [...expected] }));
 		}

package/src/tryPurgeLock.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import type { Statement } from "effect/sql/Statement";
+
+export const tryPurgeLock = Effect.fnUntraced(function* (tableName: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const [identifier] = sql`${sql(tableName)}`.compile();
+	const key = sql`hashtextextended('@shivaedev/sql/deleteBatched:' || ${identifier}::regclass::oid::text, 0)`;
+	const connection = yield* sql.reserve;
+	function execute(statement: Statement<Readonly<Record<string, unknown>>>) {
+		const [text, parameters] = statement.compile();
+		return connection.execute(text, parameters, undefined);
+	}
+	const [lock] = yield* Effect.acquireRelease(execute(sql`select pg_try_advisory_lock(${key}) as acquired`), (rows) =>
+		rows[0]?.acquired === true ? Effect.orDie(execute(sql`select pg_advisory_unlock(${key})`)) : Effect.void,
+	);
+	return lock?.acquired === true;
+});

package/src/versionedRepository.ts

@@ -4,6 +4,7 @@ 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 { UpdateInput } from "#repositoryUpdate.ts";
 import { type VersionedOptions, versionedStatements } from "#versionedStatements.ts";
 import type { RepositoryChanges } from "./repositoryChanges.ts";
 
@@ -37,9 +38,9 @@ export interface VersionedWrites<TModel extends Model.Any, TId extends PrimaryKe
 	readonly insert: Repository<TModel, TId>["insert"];
 	readonly insertVoid: Repository<TModel, TId>["insertVoid"];
 	readonly update: (
-		input: TModel["update"]["Type"],
+		input: UpdateInput<TModel>,
 	) => Effect.Effect<TModel["Type"], WriteError, TModel["update"]["EncodingServices"] | TModel["DecodingServices"]>;
-	readonly updateVoid: (input: TModel["update"]["Type"]) => Effect.Effect<void, WriteError, TModel["update"]["EncodingServices"]>;
+	readonly updateVoid: (input: UpdateInput<TModel>) => Effect.Effect<void, WriteError, TModel["update"]["EncodingServices"]>;
 }
 
 export function makeVersionedWrites(