@shivaedev/sql 0.33.0 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/sql",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "Schema-derived repositories over native Effect SQL",
   "keywords": [
     "effect"
@@ -43,17 +43,18 @@
     "README.md"
   ],
   "dependencies": {
-    "@shivaedev/changes": "0.8.0",
+    "@shivaedev/changes": "0.9.0",
     "@shivaedev/service": "0.6.1"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.6",
     "@effect/sql-pg": "4.0.6",
     "@effect/sql-sqlite-node": "4.0.6",
-    "@shivaedev/jobs": "0.30.0",
-    "@shivaedev/quality": "0.56.0",
-    "@shivaedev/test-sql": "0.16.2",
-    "@shivaedev/test-story": "0.34.0",
+    "@shivaedev/contract": "0.32.0",
+    "@shivaedev/jobs": "0.31.0",
+    "@shivaedev/quality": "0.57.0",
+    "@shivaedev/test-sql": "0.17.0",
+    "@shivaedev/test-story": "0.35.0",
     "@types/node": "24.19.2",
     "effect": "4.0.6",
     "typescript": "7.0.2",

package/src/{internal/MigrationStartedAt.ts → MigrationStartedAt.ts}

@@ -1,5 +1,5 @@
 import { Context } from "effect";
 
-export const MigrationStartedAt = Context.Reference<string | undefined>("@shivaedev/sql/internal/MigrationStartedAt", {
+export const MigrationStartedAt = Context.Reference<string | undefined>("@shivaedev/sql/MigrationStartedAt", {
 	defaultValue: () => undefined,
 });

package/src/batchWrites.ts

@@ -19,7 +19,8 @@ export function makeInsertMany<TServices = never>(
 	sql: SqlClient.SqlClient,
 	options: { readonly tableName: string; readonly spanPrefix: string; readonly changes: RepositoryChanges },
 	operation: string,
-	prepare: (row: Readonly<Record<string, unknown>>) => Effect.Effect<Fragment, Schema.SchemaError, TServices> = () => Effect.succeed(sql``),
+	prepare: (row: Readonly<Record<string, unknown>>) => Effect.Effect<Fragment, SqlError | Schema.SchemaError, TServices> = () =>
+		Effect.succeed(sql``),
 	upsert = false,
 ) {
 	const encode = Schema.encodeEffect(model.insert);

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/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/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/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/makeConflictClause.ts

@@ -1,4 +1,4 @@
-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";
@@ -44,6 +44,35 @@ export function makeConflictClause(
 		}
 		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[],
@@ -59,7 +88,7 @@ export function makeConflictClause(
 				);
 			}
 			const conflict = sql.csv(conflictColumns.map((column) => sql`${sql(column)}`));
-			const where = options.conflictWhere === undefined ? sql`` : sql`where ${yield* filter.where(options.conflictWhere)}`;
+			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 };
 });

package/src/transact.ts

@@ -1,45 +1,78 @@
-import { Effect } from "effect";
+import { Context, Effect } from "effect";
 import { dual } from "effect/Function";
 import type { ReadonlyRecord } from "effect/Record";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { SqlClient } from "effect/sql";
 import { isSqlError, type SqlError } from "effect/sql/SqlError";
-import { makeChannel } from "@shivaedev/changes/channel.ts";
-import { recordKey } from "@shivaedev/changes/keys.ts";
+import { type BeforeCommit as CommitHook, makeChannel } from "@shivaedev/changes/channel.ts";
+import { type Observation, type Observer, unobserved } from "@shivaedev/changes/observe.ts";
+import type { Publish } from "@shivaedev/changes/publish.ts";
+import { flatten, type Invalidation, keysOf } from "#invalidationKeys.ts";
 
 export type InvalidationKeys = readonly unknown[] | ReadonlyRecord<string, readonly unknown[]>;
 
-function isList(keys: InvalidationKeys): keys is readonly unknown[] {
-	return Array.isArray(keys);
+export interface AnnouncementOptions {
+	readonly publication?: "local" | "shared";
 }
 
-function flatten(keys: InvalidationKeys): readonly unknown[] {
-	return isList(keys) ? keys : Object.entries(keys).flatMap(([name, ids]) => [name, ...ids.map((id) => recordKey(name, id))]);
+type Services = SqlClient.SqlClient | Reactivity.Reactivity;
+
+export const ChangeObserver = Context.Reference<Observer<unknown>>("@shivaedev/sql/ChangeObserver", { defaultValue: () => unobserved });
+export const BeforeCommit = Context.Reference<CommitHook<unknown, SqlError, Services>>("@shivaedev/sql/BeforeCommit", {
+	defaultValue: () => () => Effect.void,
+});
+export const CommittedSink = Context.Reference<Publish<unknown, Services> | undefined>("@shivaedev/sql/CommittedSink", {
+	defaultValue: () => undefined,
+});
+
+function observe(event: Observation<Invalidation>) {
+	return Effect.flatMap(ChangeObserver, (observer) => observer({ ...event, changes: keysOf(event.changes) }));
+}
+
+function invalidate(keys: readonly unknown[]) {
+	return Reactivity.Reactivity.use((reactivity) => Effect.sync(() => reactivity.invalidateUnsafe(keys)));
 }
 
-const guard = Effect.fn("Transact.guard")(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const native = yield* Effect.serviceOption(sql.transactionService);
-	if (native._tag === "Some") {
-		return yield* Effect.die(
-			new Error("transact cannot announce changes after a transaction it does not own; begin the outer transaction with transact"),
-		);
+const committed = Effect.fnUntraced(function* (changes: readonly Invalidation[]) {
+	const sink = yield* CommittedSink;
+	if (sink === undefined) {
+		return yield* invalidate(keysOf(changes));
+	}
+	const shared = keysOf(changes.filter((change) => change.publication === "shared"));
+	const sharedKeys = new Set(shared);
+	const local = keysOf(changes.filter((change) => change.publication === "local" && !sharedKeys.has(change.key)));
+	if (local.length > 0) {
+		yield* invalidate(local);
+	}
+	if (shared.length > 0) {
+		yield* sink(shared);
 	}
 });
 
-const invalidations = makeChannel<unknown, SqlClient.SqlClient | Reactivity.Reactivity, SqlError>({
+const invalidations = makeChannel<Invalidation, Services, SqlError>({
+	beforeCommit: (changes) => {
+		const shared = keysOf(changes.filter((change) => change.publication === "shared"));
+		return shared.length === 0 ? Effect.void : Effect.flatMap(BeforeCommit, (hook) => hook(shared));
+	},
+	key: (change) => (change.publication === "shared" ? change.key : change),
 	name: "@shivaedev/sql/transact",
 	owner: Effect.map(SqlClient.SqlClient, (sql) => sql.transactionService),
-	publish: (keys) => Reactivity.Reactivity.use((reactivity) => Effect.sync(() => reactivity.invalidateUnsafe(keys))),
-	unowned: guard(),
+	publish: (changes) => invalidate(keysOf(changes)),
+	unowned: Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const native = yield* Effect.serviceOption(sql.transactionService);
+		if (native._tag === "Some") {
+			return yield* Effect.die(
+				new Error("transact cannot announce changes after a transaction it does not own; begin the outer transaction with transact"),
+			);
+		}
+	}),
 });
 
-export const ChangeObserver = invalidations.Observer;
-export const BeforeCommit = invalidations.BeforeCommit;
-export const CommittedSink = invalidations.CommittedSink;
-
-export const invalidateOnCommit = Effect.fn("Transact.invalidateOnCommit")(function* (keys: InvalidationKeys) {
-	yield* invalidations.record(flatten(keys));
+export const invalidateOnCommit = Effect.fn("Transact.invalidateOnCommit")(function* (keys: InvalidationKeys, options?: AnnouncementOptions) {
+	yield* invalidations
+		.record(flatten(keys).map((key) => ({ key, publication: options?.publication ?? "shared" })))
+		.pipe(Effect.provideService(invalidations.Observer, observe));
 });
 
 export interface TransactOptions<TError> {
@@ -65,6 +98,10 @@ export const transact: {
 					? sql.withTransaction(body)
 					: boundary.restore(sql.withTransaction(Effect.tap(body, () => sql.afterCommit(boundary.committed)))),
 			)(effect)
-			.pipe(Effect.catchIf(isSqlError, (error) => Effect.fail(options.onSqlError(error))));
+			.pipe(
+				Effect.provideService(invalidations.Observer, observe),
+				Effect.provideService(invalidations.CommittedSink, committed),
+				Effect.catchIf(isSqlError, (error) => Effect.fail(options.onSqlError(error))),
+			);
 	}),
 );

package/dist/internal/CommandRecovery.d.ts

@@ -1,3 +0,0 @@
-import { Context, Effect } from "effect";
-export declare const CommandRecovery: Context.Reference<Effect.Effect<void, never, never>>;
-//# sourceMappingURL=CommandRecovery.d.ts.map

package/dist/internal/CommandRecovery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandRecovery.d.ts","sourceRoot":"","sources":["../../src/internal/CommandRecovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,eAAO,MAAM,eAAe,sDAE1B,CAAC"}

package/dist/internal/CommandRecovery.js

@@ -1,5 +0,0 @@
-import { Context, Effect } from "effect";
-export const CommandRecovery = Context.Reference("@shivaedev/sql/CommandRecovery", {
-    defaultValue: () => Effect.void,
-});
-//# sourceMappingURL=CommandRecovery.js.map

package/dist/internal/CommandRecovery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandRecovery.js","sourceRoot":"","sources":["../../src/internal/CommandRecovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,CAAsB,gCAAgC,EAAE;IACvG,YAAY,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI;CAC/B,CAAC,CAAC"}

package/dist/internal/MigrationStartedAt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MigrationStartedAt.d.ts","sourceRoot":"","sources":["../../src/internal/MigrationStartedAt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,eAAO,MAAM,kBAAkB,uCAE7B,CAAC"}

package/dist/internal/MigrationStartedAt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MigrationStartedAt.js","sourceRoot":"","sources":["../../src/internal/MigrationStartedAt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC,SAAS,CAAqB,4CAA4C,EAAE;IACrH,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS;CAC7B,CAAC,CAAC"}