@shivaedev/sql 0.32.0 → 0.34.0

package/src/batchedDelete.ts

@@ -7,27 +7,62 @@ import type { RepositoryChanges } from "#repositoryChanges.ts";
 import { type FindManyFilter, makeFilter } from "#repositoryFilter.ts";
 import { tryPurgeLock } from "#tryPurgeLock.ts";
 
-export interface BatchedDeleteOptions<TModel extends Model.Any> {
+export interface PurgeLimits {
 	readonly batchSize: number;
 	readonly maxRows: number;
 	readonly pause: Duration.Input;
-	readonly where: FindManyFilter<TModel>;
 }
 
 export class BatchedDeleteUnavailable extends Data.TaggedError("BatchedDeleteUnavailable")<{
 	readonly reason: "transaction" | "dialect";
 }> {}
 
+export const PositiveRowCount = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+const Nonnegative = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+const Limits = Schema.Struct({ batchSize: PositiveRowCount, maxRows: Nonnegative });
+
+export const runPurgeBatches = Effect.fnUntraced(function* <E, R>(
+	tableName: string,
+	options: PurgeLimits,
+	batch: (limit: number) => Effect.Effect<{ readonly count: number; readonly done: boolean }, E, R>,
+	prepare?: Effect.Effect<unknown, E, R>,
+) {
+	const sql = yield* SqlClient.SqlClient;
+	if (sql.driver !== "pg") {
+		return yield* new BatchedDeleteUnavailable({ reason: "dialect" });
+	}
+	if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {
+		return yield* new BatchedDeleteUnavailable({ reason: "transaction" });
+	}
+	const { batchSize, maxRows } = yield* Schema.decodeUnknownEffect(Limits)(options);
+	if (prepare !== undefined) {
+		yield* prepare;
+	}
+	if (maxRows === 0 || !(yield* tryPurgeLock(tableName))) {
+		return 0;
+	}
+	let removed = 0;
+	while (removed < maxRows) {
+		const { count, done } = yield* batch(Math.min(batchSize, maxRows - removed));
+		removed += count;
+		if (done || count === 0 || removed === maxRows) {
+			break;
+		}
+		yield* Effect.sleep(options.pause);
+	}
+	return removed;
+});
+
+export interface BatchedDeleteOptions<TModel extends Model.Any> extends PurgeLimits {
+	readonly where: FindManyFilter<TModel>;
+}
+
 export interface BatchedDelete<TModel extends Model.Any> {
 	readonly deleteBatched: (
 		options: BatchedDeleteOptions<TModel>,
 	) => Effect.Effect<number, SqlError | Schema.SchemaError | BatchedDeleteUnavailable, TModel["fields"][keyof TModel["fields"]]["EncodingServices"]>;
 }
 
-const Positive = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
-const Nonnegative = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
-const Limits = Schema.Struct({ batchSize: Positive, maxRows: Nonnegative });
-
 export const makeBatchedDelete = Effect.fnUntraced(function* (
 	model: Model.Any,
 	{ tableName, spanPrefix }: { readonly tableName: string; readonly spanPrefix: string },
@@ -35,14 +70,6 @@ export const makeBatchedDelete = Effect.fnUntraced(function* (
 ) {
 	const sql = yield* SqlClient.SqlClient;
 	const { where } = makeFilter(model, sql);
-	const available = Effect.gen(function* () {
-		if (sql.driver !== "pg") {
-			return yield* new BatchedDeleteUnavailable({ reason: "dialect" });
-		}
-		if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {
-			return yield* new BatchedDeleteUnavailable({ reason: "transaction" });
-		}
-	});
 	function deleteBatch(predicate: Fragment, limit: number) {
 		const count = SqlSchema.findOne({
 			execute: (batchLimit) => sql`with removed as (
@@ -62,32 +89,18 @@ export const makeBatchedDelete = Effect.fnUntraced(function* (
 		);
 	}
 
-	const runBatches = Effect.fnUntraced(function* (options: BatchedDeleteOptions<Model.Any>, predicate: Fragment) {
-		const { batchSize, maxRows } = options;
-		let removed = 0;
-		while (removed < maxRows) {
-			const limit = Math.min(batchSize, maxRows - removed);
-			const count = yield* deleteBatch(predicate, limit);
-			removed += count;
-			if (count < limit || removed === maxRows) {
-				break;
-			}
-			yield* Effect.sleep(options.pause);
-		}
-		return removed;
-	});
-
 	return (options: BatchedDeleteOptions<Model.Any>) =>
 		Effect.gen(function* () {
-			yield* available;
-			const { maxRows } = yield* Schema.decodeUnknownEffect(Limits)(options);
-			const predicate = yield* where(options.where, true, true);
-			if (maxRows === 0) {
-				return 0;
-			}
-			if (!(yield* tryPurgeLock(tableName).pipe(Effect.provideService(SqlClient.SqlClient, sql)))) {
-				return 0;
-			}
-			return yield* runBatches(options, predicate);
-		}).pipe(Effect.scoped, Effect.withSpan(`${spanPrefix}.deleteBatched`));
+			const predicate = yield* Effect.cached(where(options.where, true, true));
+			return yield* runPurgeBatches(
+				tableName,
+				options,
+				(limit) =>
+					Effect.gen(function* () {
+						const count = yield* deleteBatch(yield* predicate, limit);
+						return { count, done: count < limit };
+					}),
+				predicate,
+			);
+		}).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.scoped, Effect.withSpan(`${spanPrefix}.deleteBatched`));
 });

package/src/changes.ts

@@ -0,0 +1,12 @@
+import { type BucketKey, type ItemKey, invalidationKeys } from "@shivaedev/changes/keys.ts";
+import { type AnnouncementOptions, invalidateOnCommit } from "#transact.ts";
+
+export interface ChangeDeclaration {
+	readonly covers: Readonly<Record<string, readonly (ItemKey | BucketKey)[]>>;
+	readonly record: (options?: AnnouncementOptions) => ReturnType<typeof invalidateOnCommit>;
+}
+
+export function changes(covers: ChangeDeclaration["covers"]): ChangeDeclaration {
+	const keys = invalidationKeys(Object.values(covers).flat());
+	return { covers, record: (options) => invalidateOnCommit(keys, options) };
+}

package/src/conditionalUpsert.ts

@@ -3,9 +3,10 @@ import type { Model } from "effect/schema";
 import type { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import { makeConflictClause } from "#makeConflictClause.ts";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
 import type { Comparisons, FindManyFilter } from "#repositoryFilter.ts";
-import type { RepositoryChanges } from "./repositoryChanges.ts";
-import { makeUpsertDecoder, type UpsertRow, upsertReturning } from "./upsertResult.ts";
+import type { UpsertAssignment } from "#upsertColumns.ts";
+import { makeUpsertDecoder, type UpsertRow, upsertReturning } from "#upsertResult.ts";
 
 type Fields<TModel extends Model.Any> = Schema.Struct.Type<TModel["fields"]>;
 interface Incoming<TModel extends Model.Any, TValue> {
@@ -70,7 +71,7 @@ export function makeConditionalUpsert(
 	const clause = makeConflictClause(model, sql, options);
 	return (
 		inputs: readonly unknown[],
-		settings: { readonly updateColumns: readonly string[]; readonly updateWhere: Readonly<Record<string, unknown>> },
+		settings: { readonly updateColumns: readonly UpsertAssignment[]; readonly updateWhere: Readonly<Record<string, unknown>> },
 	) =>
 		Effect.gen(function* () {
 			const statements = yield* Effect.forEach(inputs, (input) =>

package/src/conflictWrites.ts

@@ -6,15 +6,16 @@ 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 { makeUpsertDecoder, upsertReturning } from "./upsertResult.ts";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
+import type { UpsertAssignment, UpsertColumn } from "#upsertColumns.ts";
+import { makeUpsertDecoder, upsertReturning } from "#upsertResult.ts";
 
 export type InsertColumn<TModel extends Model.Any> = Extract<keyof TModel["insert"]["Type"] & keyof TModel["fields"], string>;
 export type ConflictColumns<TModel extends Model.Any> = readonly [InsertColumn<TModel>, ...InsertColumn<TModel>[]];
 interface UpdateOptions<TModel extends Model.Any, TExcluded extends PropertyKey> {
 	readonly updateColumns: readonly [
-		Exclude<InsertColumn<TModel> & keyof TModel["update"]["Type"], TExcluded>,
-		...Exclude<InsertColumn<TModel> & keyof TModel["update"]["Type"], TExcluded>[],
+		UpsertColumn<TModel, Exclude<InsertColumn<TModel> & keyof TModel["update"]["Type"], TExcluded>>,
+		...UpsertColumn<TModel, Exclude<InsertColumn<TModel> & keyof TModel["update"]["Type"], TExcluded>>[],
 	];
 }
 export interface ConflictWrites<TModel extends Model.Any, TExcluded extends PropertyKey, TFilterServices = never> {
@@ -58,7 +59,7 @@ export function makeConflictWrites(
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const conditional = makeConditionalUpsert(model, sql, options);
 	const clause = makeConflictClause(model, sql, options);
-	function statement(input: unknown, updateColumns?: readonly string[]) {
+	function statement(input: unknown, updateColumns?: readonly UpsertAssignment[]) {
 		return Effect.gen(function* () {
 			const encoded = yield* record(yield* encode(input));
 			const suffix = yield* clause(encoded, updateColumns);
@@ -76,7 +77,10 @@ export function makeConflictWrites(
 				yield* options.changes.record(rows);
 				return rows.length === 0 ? Option.none() : Option.some(yield* decode(rows[0]));
 			}).pipe(options.changes.write, Effect.withSpan(`${spanPrefix}.insertOrIgnore`)),
-		upsert: (input: unknown, settings: { readonly updateColumns: readonly string[]; readonly updateWhere?: Readonly<Record<string, unknown>> }) =>
+		upsert: (
+			input: unknown,
+			settings: { readonly updateColumns: readonly UpsertAssignment[]; readonly updateWhere?: Readonly<Record<string, unknown>> },
+		) =>
 			settings.updateWhere === undefined
 				? Effect.gen(function* () {
 						const rows = yield* yield* statement(input, settings.updateColumns);
@@ -86,7 +90,7 @@ export function makeConflictWrites(
 				: conditional([input], { ...settings, updateWhere: settings.updateWhere }).pipe(Effect.map((results) => results[0])),
 		upsertMany: (
 			inputs: readonly unknown[],
-			settings: { readonly updateColumns: readonly string[]; readonly updateWhere?: Readonly<Record<string, unknown>> },
+			settings: { readonly updateColumns: readonly UpsertAssignment[]; readonly updateWhere?: Readonly<Record<string, unknown>> },
 		) =>
 			settings.updateWhere === undefined
 				? makeInsertMany(model, sql, options, "upsertMany", (row) => clause(row, settings.updateColumns), true)(inputs)

package/src/deleteGroupsBatched.ts

@@ -0,0 +1,41 @@
+import { Effect, Schema } from "effect";
+import { PositiveRowCount, type PurgeLimits, runPurgeBatches } from "#batchedDelete.ts";
+import { transact } from "#transact.ts";
+
+export interface DeleteGroup<T> {
+	readonly rowCount: number;
+	readonly value: T;
+}
+
+export interface DeleteGroupsBatchedOptions<T, TSelectError, TSelectServices, TDeleteError, TDeleteServices> extends PurgeLimits {
+	readonly delete: (group: T) => Effect.Effect<unknown, TDeleteError, TDeleteServices>;
+	readonly select: (limit: number) => Effect.Effect<readonly DeleteGroup<T>[], TSelectError, TSelectServices>;
+	readonly tableName: string;
+}
+
+export const deleteGroupsBatched = Effect.fn("Sql.deleteGroupsBatched")(function* <T, TSelectError, TSelectServices, TDeleteError, TDeleteServices>(
+	options: DeleteGroupsBatchedOptions<T, TSelectError, TSelectServices, TDeleteError, TDeleteServices>,
+) {
+	return yield* runPurgeBatches(options.tableName, options, (limit) =>
+		transact(
+			Effect.gen(function* () {
+				const candidates = yield* options.select(limit);
+				const selected: T[] = [];
+				let count = 0;
+				for (const candidate of candidates) {
+					const size = yield* Schema.decodeUnknownEffect(PositiveRowCount)(candidate.rowCount);
+					if (size > limit - count) {
+						break;
+					}
+					selected.push(candidate.value);
+					count += size;
+				}
+				for (const group of selected) {
+					yield* options.delete(group);
+				}
+				return { count, done: candidates.length === 0 };
+			}),
+			{ onSqlError: (error) => error },
+		),
+	).pipe(Effect.scoped);
+});

package/src/inValues.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import type { Fragment } from "effect/sql/Statement";
+
+export const inValues = Effect.fnUntraced(function* (column: string | Fragment, values: readonly unknown[]) {
+	const sql = yield* SqlClient.SqlClient;
+	if (values.length === 0) {
+		return sql`1 = 0`;
+	}
+	return sql`${typeof column === "string" ? sql(column) : column} in ${sql.in(values)}`;
+});

package/src/insertFromSelect.ts

@@ -29,7 +29,7 @@ export function makeInsertFromSelect<TServices = never>(
 	sql: SqlClient.SqlClient,
 	options: { readonly tableName: string; readonly spanPrefix: string; readonly changes: RepositoryChanges },
 	operation: string,
-	prepare: (columns: readonly string[]) => Effect.Effect<Fragment, Schema.SchemaError, TServices> = () => Effect.succeed(sql``),
+	prepare: (columns: readonly string[]) => Effect.Effect<Fragment, SqlError | Schema.SchemaError, TServices> = () => Effect.succeed(sql``),
 ) {
 	const decode = Schema.decodeUnknownEffect(Schema.Array(model));
 	return (source: RepositorySelect<Schema.Struct.Fields, unknown>, columns: Readonly<Record<string, string>>) =>

package/src/int4Array.ts

@@ -0,0 +1,14 @@
+import * as PgTypes from "@effect/sql-pg/PgTypes";
+import { Result, Schema, SchemaGetter, SchemaParser } from "effect";
+
+const Integers = Schema.Array(Schema.Int);
+
+export function int4Array<TField extends Schema.Top & { readonly Encoded: readonly number[] }>(field: TField) {
+	return Schema.Unknown.pipe(
+		Schema.decodeTo(Integers, {
+			decode: SchemaGetter.transformEffect((value) => SchemaParser.decodeUnknownEffect(Integers)(PgTypes.isParameter(value) ? value.value : value)),
+			encode: SchemaGetter.transform((values) => Result.getOrThrow(PgTypes.array(values, PgTypes.OID.int4))),
+		}),
+		Schema.decodeTo(field),
+	);
+}

package/src/int8.ts

@@ -0,0 +1,14 @@
+import * as PgTypes from "@effect/sql-pg/PgTypes";
+import { Schema, SchemaGetter, SchemaParser } from "effect";
+
+export function int8<TField extends Schema.Top & { readonly Encoded: bigint }>(field: TField) {
+	return Schema.Unknown.pipe(
+		Schema.decodeTo(Schema.BigInt, {
+			decode: SchemaGetter.transformEffect((value) =>
+				SchemaParser.decodeUnknownEffect(Schema.BigInt)(PgTypes.isParameter(value) ? value.value : value),
+			),
+			encode: SchemaGetter.transform(PgTypes.int8),
+		}),
+		Schema.decodeTo(field),
+	);
+}

package/src/invalidationKeys.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+import { invalidationKeys, Key, recordKey } from "@shivaedev/changes/keys.ts";
+import type { InvalidationKeys } from "#transact.ts";
+
+export interface Invalidation {
+	readonly key: unknown;
+	readonly publication: "local" | "shared";
+}
+
+const isKey = Schema.is(Key);
+
+function isList(keys: InvalidationKeys): keys is readonly unknown[] {
+	return Array.isArray(keys);
+}
+
+export function flatten(keys: InvalidationKeys): readonly unknown[] {
+	return isList(keys)
+		? keys.flatMap<unknown>((key) => (isKey(key) ? invalidationKeys([key]) : [key]))
+		: Object.entries(keys).flatMap(([name, ids]) => [name, ...ids.map((id) => recordKey(name, id))]);
+}
+
+export function keysOf(changes: readonly Invalidation[]) {
+	return [...new Set(changes.map((change) => change.key))];
+}

package/src/keysetPage.ts

@@ -0,0 +1,54 @@
+import { Effect, Option, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import type { Fragment } from "effect/sql/Statement";
+
+export interface KeysetOrder<TCursor> {
+	readonly column: string | Fragment;
+	readonly direction: "asc" | "desc";
+	readonly value: (cursor: TCursor) => string | number | bigint | boolean;
+}
+
+export interface KeysetPageQuery {
+	readonly limit: number;
+	readonly orderBy: Fragment;
+	readonly seek: Fragment;
+}
+
+export interface KeysetPage<TRow, TCursor> {
+	readonly next: Option.Option<TCursor>;
+	readonly rows: readonly TRow[];
+}
+
+const PageSize = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThan(Number.MAX_SAFE_INTEGER));
+
+export const keysetPage = Effect.fnUntraced(function* <TRow, TCursor, E, R>(options: {
+	readonly limit: number;
+	readonly after?: TCursor | undefined;
+	readonly orderBy: readonly KeysetOrder<TCursor>[];
+	readonly tieBreaker: KeysetOrder<TCursor>;
+	readonly cursorFor: (row: TRow) => TCursor;
+	readonly read: (query: KeysetPageQuery) => Effect.Effect<readonly TRow[], E, R>;
+}): Effect.fn.Return<KeysetPage<TRow, TCursor>, E | Schema.SchemaError, R | SqlClient.SqlClient> {
+	const limit = yield* Schema.decodeUnknownEffect(PageSize)(options.limit);
+	const sql = yield* SqlClient.SqlClient;
+	const order = [...options.orderBy, options.tieBreaker];
+	const columns = order.map(({ column }) => (typeof column === "string" ? sql`${sql(column)}` : column));
+	const after = options.after;
+	const values = after === undefined ? undefined : order.map(({ value }) => value(after));
+	const seek =
+		values === undefined
+			? sql`true`
+			: sql.or(
+					order.map(({ direction }, index) =>
+						sql.and([
+							...columns.slice(0, index).map((column, previous) => sql`${column} = ${values[previous]}`),
+							direction === "asc" ? sql`${columns[index]} > ${values[index]}` : sql`${columns[index]} < ${values[index]}`,
+						]),
+					),
+				);
+	const orderBy = sql.csv(order.map(({ direction }, index) => sql`${columns[index]} ${sql.literal(direction === "asc" ? "asc" : "desc")}`));
+	const found = yield* options.read({ limit: limit + 1, orderBy, seek });
+	const rows = found.slice(0, limit);
+	const last = rows.at(-1);
+	return { next: found.length > limit && last !== undefined ? Option.some(options.cursorFor(last)) : Option.none(), rows };
+});

package/src/listenForChanges.ts

@@ -89,11 +89,11 @@ export const listenForChanges = Effect.fn("PostgresChanges.listenForChanges")(fu
 						return;
 					}
 					if (lostAt !== undefined) {
-						yield* Effect.logDebug("PostgreSQL change listener reconnect failed; retrying", cause);
+						yield* Effect.logDebug("PostgreSQL change listener reconnect failed; retrying");
 						return;
 					}
 					lostAt = yield* Clock.currentTimeMillis;
-					yield* Effect.logWarning("PostgreSQL change listener lost; resynchronizing live streams", cause);
+					yield* Effect.logWarning("PostgreSQL change listener lost; resynchronizing live streams");
 				}).pipe(Effect.andThen(Effect.sleep(options.retryDelay ?? "1 second"))),
 			),
 		),

package/src/makeConflictClause.ts

@@ -1,7 +1,8 @@
-import { Effect, Schema, SchemaAST, SchemaIssue } from "effect";
+import { Array as Arr, Effect, Schema, SchemaAST, SchemaIssue } from "effect";
 import type { Model } from "effect/schema";
 import type { SqlClient } from "effect/sql";
 import { makeFilter } from "#repositoryFilter.ts";
+import type { UpsertAssignment } from "#upsertColumns.ts";
 
 export function makeConflictClause(
 	model: Model.Any,
@@ -33,18 +34,62 @@ export function makeConflictClause(
 			}
 		});
 	}
-	function clause(encoded: Readonly<Record<string, unknown>>, updateColumns?: readonly string[], updateWhere?: Readonly<Record<string, unknown>>) {
+	function assignment(entry: UpsertAssignment) {
+		const column = typeof entry === "string" ? entry : entry.column;
+		const incoming = sql`excluded.${sql(column)}`;
+		const stored = sql`${sql(options.tableName)}.${sql(column)}`;
+		let value = incoming;
+		if (typeof entry !== "string") {
+			value = entry.mode === "add" ? sql`${stored} + ${incoming}` : sql`coalesce(${incoming}, ${stored})`;
+		}
+		return sql`${sql(column)} = ${value}`;
+	}
+	function encodePredicate([key, value]: readonly [string, unknown]) {
+		return Effect.gen(function* () {
+			const field = yield* filter.fieldAt(key);
+			const encoded = yield* Schema.encodeEffect(field)(value);
+			return { encoded, key, nullish: value === null || encoded === null };
+		});
+	}
+	function postgresPredicate(input: Readonly<Record<string, unknown>>) {
+		return Effect.gen(function* () {
+			const entries = yield* Effect.forEach(
+				Object.entries(input).filter(([, value]) => value !== undefined),
+				encodePredicate,
+			);
+			if (entries.length === 0) {
+				return sql.and([]);
+			}
+			// PostgreSQL must see constants to infer a partial index under generic plans.
+			const [quoted] = yield* sql`select ${sql.csv(entries.map(({ encoded }) => sql`quote_nullable(${encoded}::text)`))}`.values;
+			const literals = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.String))(quoted);
+			return sql.and(
+				Arr.zip(entries, literals).map(([{ key, nullish }, literal]) =>
+					nullish ? sql`${sql(key)} is null` : sql`${sql(key)} = ${sql.literal(literal)}`,
+				),
+			);
+		});
+	}
+	function conflictPredicate(input: Readonly<Record<string, unknown>>) {
+		return sql.onDialectOrElse({ orElse: () => filter.where(input), pg: () => postgresPredicate(input) });
+	}
+	function clause(
+		encoded: Readonly<Record<string, unknown>>,
+		updateColumns?: readonly UpsertAssignment[],
+		updateWhere?: Readonly<Record<string, unknown>>,
+	) {
 		return Effect.gen(function* () {
 			yield* validateColumns(encoded, conflictColumns);
 			if (updateColumns !== undefined) {
-				yield* validateColumns(encoded, updateColumns, [...idColumns, ...conflictColumns, ...immutable]);
+				yield* validateColumns(
+					encoded,
+					updateColumns.map((entry) => (typeof entry === "string" ? entry : entry.column)),
+					[...idColumns, ...conflictColumns, ...immutable],
+				);
 			}
 			const conflict = sql.csv(conflictColumns.map((column) => sql`${sql(column)}`));
-			const where = options.conflictWhere === undefined ? sql`` : sql`where ${yield* filter.where(options.conflictWhere)}`;
-			const action =
-				updateColumns === undefined
-					? sql`do nothing`
-					: sql`do update set ${sql.csv(updateColumns.map((column) => sql`${sql(column)} = excluded.${sql(column)}`))}`;
+			const where = options.conflictWhere === undefined ? sql`` : sql`where ${yield* conflictPredicate(options.conflictWhere)}`;
+			const action = updateColumns === undefined ? sql`do nothing` : sql`do update set ${sql.csv(updateColumns.map(assignment))}`;
 			const condition = updateWhere === undefined ? sql`` : sql`where ${yield* updateFilter.where(updateWhere, true, true)}`;
 			return sql`on conflict (${conflict}) ${where} ${action} ${condition}`;
 		});

package/src/migrations.ts

@@ -2,12 +2,12 @@ import { Duration, Effect, Option, Schema } from "effect";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { Migrator, SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
-import { MigrationStartedAt } from "#internal/MigrationStartedAt.ts";
-import { migrationLock } from "#internal/migrationLock.ts";
-import { advisoryXactLock } from "./advisoryXactLock.ts";
-import { postgresRelease } from "./postgresRelease.ts";
-import { runSchemaComponent, type SchemaComponent } from "./SchemaComponent.ts";
-import { transact } from "./transact.ts";
+import { advisoryXactLock } from "#advisoryXactLock.ts";
+import { MigrationStartedAt } from "#MigrationStartedAt.ts";
+import { migrationLock } from "#migrationLock.ts";
+import { postgresRelease } from "#postgresRelease.ts";
+import { runSchemaComponent, type SchemaComponent } from "#SchemaComponent.ts";
+import { transact } from "#transact.ts";
 
 export interface PostgresMigrationOptions<R, E = never> {
 	readonly components?: readonly SchemaComponent<R, E>[];
@@ -52,12 +52,12 @@ export const migratePostgres = Effect.fn("EffectSql.migratePostgres")(function*
   created_at timestamp with time zone not null default now(),
   name text not null
 )`;
-		const applied = yield* sql`select migration_id as id from ${sql(table)}`.withoutTransform.pipe(
-			Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ id: Schema.Int })))),
+		const applied = yield* sql`select migration_id as id, name from ${sql(table)}`.withoutTransform.pipe(
+			Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ id: Schema.Int, name: Schema.String })))),
 		);
-		const appliedIds = new Set(applied.map(({ id }) => id));
+		const appliedNames = new Map(applied.map(({ id, name }) => [id, name]));
 		const latest = applied.reduce((max, { id }) => Math.max(max, id), 0);
-		const missing = current.filter(([id]) => id <= latest && !appliedIds.has(id));
+		const missing = current.filter(([id]) => id <= latest && !appliedNames.has(id));
 		if (missing.length > 0) {
 			return yield* Effect.fail(
 				new Migrator.MigrationError({
@@ -66,6 +66,17 @@ export const migratePostgres = Effect.fn("EffectSql.migratePostgres")(function*
 				}),
 			);
 		}
+		for (const [id, name] of current) {
+			const recorded = appliedNames.get(id);
+			if (recorded !== undefined && recorded !== name) {
+				return yield* Effect.fail(
+					new Migrator.MigrationError({
+						kind: "BadState",
+						message: `Migration ${id} is recorded as ${JSON.stringify(recorded)} but loaded as ${JSON.stringify(name)}`,
+					}),
+				);
+			}
+		}
 		return yield* migrate({ loader: Effect.succeed(current), table });
 	}).pipe(transact({ onSqlError: (error) => error }), Effect.provideService(Reactivity.Reactivity, reactivity));
 	const schemaComponents: readonly SchemaComponent<R, E | SqlError | Schema.SchemaError>[] = [

package/src/postgresChanges.ts

@@ -2,10 +2,10 @@ import { Context, type Duration, Effect, Layer, type Queue, type Scope } from "e
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
-import { CommandRecovery } from "#internal/CommandRecovery.ts";
+import { CommandPublication, CommandPublicationError, type CommandPublisher } from "@shivaedev/changes/commandPublication.ts";
 import { listenForChanges } from "./listenForChanges.ts";
 import { encodeKeys, resyncPayload } from "./notifyPayload.ts";
-import { BeforeCommit, CommittedSink } from "./transact.ts";
+import { BeforeCommit, CommittedSink, invalidateOnCommit, transact } from "./transact.ts";
 
 export interface PostgresNotification {
 	readonly payload: string;
@@ -48,10 +48,19 @@ export function postgresChanges(options: PostgresChangesOptions) {
 			}
 			const recover = options.resync.pipe(
 				Effect.andThen(options.client`select pg_notify(${options.channel}, ${resyncPayload})`),
-				Effect.catchCause((cause) => Effect.logError("Committed command Resync broadcast failed; other hosts may remain stale", cause)),
+				Effect.catchCause((cause) => Effect.fail(new CommandPublicationError({ cause }))),
 				Effect.asVoid,
 			);
-			return Context.make(BeforeCommit, notify).pipe(Context.add(CommittedSink, committed), Context.add(CommandRecovery, recover));
+			const publication: CommandPublisher = {
+				publish: (keys) =>
+					invalidateOnCommit(keys).pipe(
+						transact({ onSqlError: (error) => error }),
+						Effect.provideService(SqlClient.SqlClient, options.client),
+						Effect.catchCause((cause) => Effect.fail(new CommandPublicationError({ cause }))),
+					),
+				recover,
+			};
+			return Context.make(BeforeCommit, notify).pipe(Context.add(CommittedSink, committed), Context.add(CommandPublication, publication));
 		}),
 	);
 }

package/src/postgresLayer.ts

@@ -26,5 +26,5 @@ export function postgresLayer(url: Redacted.Redacted<string>, options?: Postgres
 			const client = yield* makePostgresClient(config).pipe(Effect.provideService(PgPool.PgPool, pool));
 			return Context.make(PgPool.PgPool, pool).pipe(Context.add(PgClient.PgClient, client), Context.add(SqlClient.SqlClient, client));
 		}),
-	).pipe(Layer.provide(Reactivity.layer));
+	).pipe(Layer.provideMerge(Layer.fresh(Reactivity.layer)));
 }

package/src/postgresRelease.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/sql";
-import { MigrationStartedAt } from "#internal/MigrationStartedAt.ts";
+import { MigrationStartedAt } from "#MigrationStartedAt.ts";
 import type { SchemaComponent } from "./SchemaComponent.ts";
 
 export const readPostgresRelease = Effect.fn("EffectSql.readPostgresRelease")(function* (table = "effect_sql_migrations") {

package/src/repositoryChanges.ts

@@ -2,7 +2,7 @@ import { Effect, Option, type Schema } from "effect";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { SqlClient } from "effect/sql";
 import { declaredBuckets } from "@shivaedev/changes/buckets.ts";
-import { compositeId, invalidationKeys, type Key, recordKey } from "@shivaedev/changes/keys.ts";
+import { collectionInvalidationKeys, compositeId, invalidationKeys, type Key, recordKey } from "@shivaedev/changes/keys.ts";
 import { ChangeDeclarations } from "#ChangeDeclarations.ts";
 import { invalidateOnCommit, transact } from "#transact.ts";
 
@@ -71,8 +71,9 @@ export const repositoryChanges = Effect.fnUntraced(function* (
 			return;
 		}
 		const declarations = yield* ChangeDeclarations;
-		yield* declarations.declare(table, [table], rows);
-		yield* provide(invalidateOnCommit([table]));
+		const keys = collectionInvalidationKeys(table);
+		yield* declarations.declare(table, keys, rows);
+		yield* provide(invalidateOnCommit(keys));
 	});
 	return { record, recordTable, returning, write };
 });