@shivaedev/sql 0.33.0 → 0.35.0

package/src/makeAggregate.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema, SchemaIssue } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient } from "effect/sql";
+import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import type { Fragment } from "effect/sql/Statement";
 import { aggregateColumn } from "#aggregateColumn.ts";
@@ -10,55 +10,56 @@ import { type FindManyFilter, makeFilter } from "#repositoryFilter.ts";
 
 export function makeAggregate<TModel extends Model.Any>(
 	model: TModel,
-	sql: SqlClient.SqlClient,
 	options: { readonly tableName: string; readonly spanPrefix: string },
-): Aggregate<TModel>;
+): Effect.Effect<Aggregate<TModel>, never, SqlClient.SqlClient>;
 export function makeAggregate(
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: { readonly tableName: string; readonly spanPrefix: string },
-): unknown {
-	const { fieldAt, where } = makeFilter(model, sql);
-	const selectAggregate = aggregateColumn(sql, fieldAt);
-	return (query: {
-		readonly groupBy: readonly string[];
-		readonly aggregates: Readonly<Record<string, object>>;
-		readonly where?: FindManyFilter<Model.Any>;
-		readonly orderBy?: readonly { readonly field: string; readonly direction: "asc" | "desc" }[];
-		readonly limit?: number;
-	}): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> =>
-		Effect.gen(function* () {
-			const groups = yield* Schema.decodeUnknownEffect(Schema.NonEmptyArray(Schema.String))(query.groupBy);
-			const fields = new Map<string, Schema.Constraint>();
-			const columns: Fragment[] = [];
-			const ordering = new Map<string, Fragment>();
-			for (const key of groups) {
-				fields.set(key, yield* fieldAt(key));
-				columns.push(sql`${sql(key)}`);
-			}
-			for (const [name, expression] of Object.entries(query.aggregates)) {
-				if (groups.includes(name)) {
-					return yield* Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([name], new SchemaIssue.UnexpectedKey(model.ast, name))));
+): Effect.Effect<unknown, never, SqlClient.SqlClient> {
+	return Effect.fnUntraced(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const { fieldAt, where } = yield* makeFilter(model);
+		const selectAggregate = yield* aggregateColumn(fieldAt);
+		return (query: {
+			readonly groupBy: readonly string[];
+			readonly aggregates: Readonly<Record<string, object>>;
+			readonly where?: FindManyFilter<Model.Any>;
+			readonly orderBy?: readonly { readonly field: string; readonly direction: "asc" | "desc" }[];
+			readonly limit?: number;
+		}): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> =>
+			Effect.gen(function* () {
+				const groups = yield* Schema.decodeUnknownEffect(Schema.NonEmptyArray(Schema.String))(query.groupBy);
+				const fields = new Map<string, Schema.Constraint>();
+				const columns: Fragment[] = [];
+				const ordering = new Map<string, Fragment>();
+				for (const key of groups) {
+					fields.set(key, yield* fieldAt(key));
+					columns.push(sql`${sql(key)}`);
 				}
-				const selected = yield* selectAggregate(name, expression);
-				ordering.set(name, selected.order);
-				columns.push(selected.column);
-				fields.set(name, selected.schema);
-			}
-			const Result = Schema.Struct(Object.fromEntries(fields));
-			const clauses = makeQueryClauses(
-				sql,
-				(key) =>
-					fields.has(key)
-						? Effect.succeed(fields.get(key))
-						: Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([key], new SchemaIssue.UnexpectedKey(Result.ast, key)))),
-				(key) => ordering.get(key) ?? sql`${sql(key)}`,
-			);
-			const predicate = yield* where(query.where, true, true);
-			const order = yield* clauses.orderClause(query.orderBy);
-			const limit = yield* clauses.limitClause(query.limit);
-			const partitions = sql.csv(groups.map((key) => sql`${sql(key)}`));
-			const rows = yield* sql`select ${sql.csv(columns)} from ${sql(options.tableName)} where ${predicate} group by ${partitions} ${order} ${limit}`;
-			return yield* Schema.decodeUnknownEffect(Schema.Array(Result))(rows);
-		}).pipe(Effect.withSpan(`${options.spanPrefix}.aggregate`));
+				for (const [name, expression] of Object.entries(query.aggregates)) {
+					if (groups.includes(name)) {
+						return yield* Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([name], new SchemaIssue.UnexpectedKey(model.ast, name))));
+					}
+					const selected = yield* selectAggregate(name, expression);
+					ordering.set(name, selected.order);
+					columns.push(selected.column);
+					fields.set(name, selected.schema);
+				}
+				const Result = Schema.Struct(Object.fromEntries(fields));
+				const clauses = yield* makeQueryClauses(
+					(key) =>
+						fields.has(key)
+							? Effect.succeed(fields.get(key))
+							: Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([key], new SchemaIssue.UnexpectedKey(Result.ast, key)))),
+					(key) => ordering.get(key) ?? sql`${sql(key)}`,
+				).pipe(Effect.provideService(SqlClient.SqlClient, sql));
+				const predicate = yield* where(query.where, true, true);
+				const order = yield* clauses.orderClause(query.orderBy);
+				const limit = yield* clauses.limitClause(query.limit);
+				const partitions = sql.csv(groups.map((key) => sql`${sql(key)}`));
+				const rows =
+					yield* sql`select ${sql.csv(columns)} from ${sql(options.tableName)} where ${predicate} group by ${partitions} ${order} ${limit}`;
+				return yield* Schema.decodeUnknownEffect(Schema.Array(Result))(rows);
+			}).pipe(Effect.withSpan(`${options.spanPrefix}.aggregate`));
+	})();
 }

package/src/makeConflictClause.ts

@@ -1,12 +1,11 @@
-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 { SqlClient } from "effect/sql";
 import { makeFilter } from "#repositoryFilter.ts";
 import type { UpsertAssignment } from "#upsertColumns.ts";
 
-export function makeConflictClause(
+export const makeConflictClause = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: {
 		readonly tableName: string;
 		readonly conflictColumns: readonly string[];
@@ -14,9 +13,10 @@ export function makeConflictClause(
 		readonly idColumns: readonly string[];
 	},
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	const { conflictColumns, idColumns } = options;
-	const updateFilter = makeFilter(model, sql, options);
-	const filter = makeFilter(model, sql);
+	const updateFilter = yield* makeFilter(model, options);
+	const filter = yield* makeFilter(model);
 	const updateFields = SchemaAST.isObjects(model.update.ast) ? model.update.ast.propertySignatures.map((field) => field.name) : [];
 	const immutable = Object.keys(model.fields).filter((column) => !updateFields.includes(column));
 	function invalid(column: string) {
@@ -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,11 +88,11 @@ 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}`;
 		});
 	}
 	return clause;
-}
+});

package/src/makeQueryClauses.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import type { SqlClient } from "effect/sql";
+import { SqlClient } from "effect/sql";
 import type { Fragment } from "effect/sql/Statement";
 
 const Limit = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
@@ -9,11 +9,11 @@ interface Order {
 	readonly field: string;
 }
 
-export function makeQueryClauses(
-	sql: SqlClient.SqlClient,
+export const makeQueryClauses = Effect.fnUntraced(function* (
 	fieldAt: (key: string) => Effect.Effect<unknown, Schema.SchemaError>,
-	column: (key: string) => Fragment = (key) => sql`${sql(key)}`,
+	column?: (key: string) => Fragment,
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	function orderClause(orderBy: Order | readonly Order[] | undefined) {
 		if (orderBy === undefined) {
 			return Effect.succeed(sql``);
@@ -24,7 +24,7 @@ export function makeQueryClauses(
 		}
 		return Effect.map(
 			Effect.forEach(entries, ({ field, direction }) =>
-				Effect.as(fieldAt(field), sql`${column(field)} ${sql.literal(direction === "desc" ? "desc" : "asc")}`),
+				Effect.as(fieldAt(field), sql`${column?.(field) ?? sql`${sql(field)}`} ${sql.literal(direction === "desc" ? "desc" : "asc")}`),
 			),
 			(columns) => sql`order by ${sql.csv(columns)}`,
 		);
@@ -33,4 +33,4 @@ export function makeQueryClauses(
 		return limit === undefined ? Effect.succeed(sql``) : Effect.map(decodeLimit(limit), (rowLimit) => sql`limit ${rowLimit}`);
 	}
 	return { decodeLimit, limitClause, orderClause };
-}
+});

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

@@ -1,13 +1,11 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient } from "effect/sql";
 import type { RepositoryListFilter } from "#repositoryFilter.ts";
 import { makeFilter } from "#repositoryFilter.ts";
 import { tupleFilter } from "#tupleIn.ts";
 
-export function pinnedGroups(
+export const pinnedGroups = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	partitionBy: readonly string[],
 	input: RepositoryListFilter<Model.Any> = {},
 ) {
@@ -18,7 +16,7 @@ export function pinnedGroups(
 			(value) => typeof value === "object" && value !== null && "in" in value && Array.isArray(value.in) && value.in.length === 0,
 		)
 	) {
-		return Effect.succeed({ groups: [], remaining: input, tuple: undefined });
+		return { groups: [], remaining: input, tuple: undefined };
 	}
 	const exactTuple = tuple !== undefined && tuple.fields.length === partitionBy.length && partitionBy.every((key) => tuple.fields.includes(key));
 	let groups: readonly (readonly unknown[])[] = [[]];
@@ -30,19 +28,17 @@ export function pinnedGroups(
 		for (const key of partitionBy) {
 			const value = input[key];
 			if (value === undefined) {
-				return Effect.succeed(undefined);
+				return undefined;
 			}
 			const values = typeof value === "object" && value !== null && "in" in value && Array.isArray(value.in) ? value.in : [value];
 			groups = groups.flatMap((group) => values.map((entry) => [...group, entry]));
 			delete remaining[key];
 		}
 	}
-	const { fieldAt } = makeFilter(model, sql);
-	return Effect.gen(function* () {
-		const fields = yield* Effect.forEach(partitionBy, fieldAt);
-		const groupsEncoded: readonly (readonly unknown[])[] = yield* Effect.forEach(groups, (group) =>
-			Schema.encodeUnknownEffect(Schema.Tuple(fields))(group),
-		);
-		return { groups: groupsEncoded, remaining, tuple: exactTuple ? tuple : undefined };
-	});
-}
+	const { fieldAt } = yield* makeFilter(model);
+	const fields = yield* Effect.forEach(partitionBy, fieldAt);
+	const groupsEncoded: readonly (readonly unknown[])[] = yield* Effect.forEach(groups, (group) =>
+		Schema.encodeUnknownEffect(Schema.Tuple(fields))(group),
+	);
+	return { groups: groupsEncoded, remaining, tuple: exactTuple ? tuple : undefined };
+});

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

@@ -1,6 +1,6 @@
 import { Data, Effect, type Schema } from "effect";
 import type { Model } from "effect/schema";
-import { SqlClient } from "effect/sql";
+import type { 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";
@@ -117,27 +117,26 @@ export function makeRepository<TModel extends Model.Any, TId extends IdColumn<TM
 ): 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 changes = yield* repositoryChanges(options.tableName, idColumns, model.fields);
 		const crud = {
-			...makeCompositeCrud(model, sql, { ...options, columns: idColumns }, changes),
+			...(yield* makeCompositeCrud(model, { ...options, columns: idColumns }, changes)),
 			deleteBatched: yield* makeBatchedDelete(model, options, changes),
 		};
-		const queries = makeQueries(model, sql, options);
+		const queries = yield* makeQueries(model, options);
 		return {
 			...crud,
 			...queries,
 			...(options.versionColumn === undefined
 				? {
-						insertFromSelect: makeInsertFromSelect(model, sql, { ...options, changes }, "insertFromSelect"),
-						insertMany: makeInsertMany(model, sql, { ...options, changes }, "insertMany"),
+						insertFromSelect: yield* makeInsertFromSelect(model, { ...options, changes }, "insertFromSelect"),
+						insertMany: yield* makeInsertMany(model, { ...options, changes }, "insertMany"),
 						...(options.conflictColumns === undefined
 							? {}
-							: makeConflictWrites(model, sql, { ...options, changes, conflictColumns: options.conflictColumns, idColumns })),
+							: yield* makeConflictWrites(model, { ...options, changes, conflictColumns: options.conflictColumns, idColumns })),
 					}
-				: makeVersionedWrites(model, sql, {
+				: yield* makeVersionedWrites(model, {
 						...options,
 						changes,
 						conflict: (id, expectedVersion, reason) => new OptimisticConcurrencyError({ expectedVersion, id, reason, tableName: options.tableName }),

package/src/repositoryChanges.ts

@@ -2,18 +2,14 @@ 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";
 
 export type RepositoryChanges = Effect.Success<ReturnType<typeof repositoryChanges>>;
 
-export const repositoryChanges = Effect.fnUntraced(function* (
-	sql: SqlClient.SqlClient,
-	table: string,
-	columns: readonly string[],
-	fields: Schema.Struct.Fields = {},
-) {
+export const repositoryChanges = Effect.fnUntraced(function* (table: string, columns: readonly string[], fields: Schema.Struct.Fields = {}) {
+	const sql = yield* SqlClient.SqlClient;
 	const buckets = declaredBuckets(fields);
 	const bucketKeys = Effect.fnUntraced(function* (row: Readonly<Record<string, unknown>>) {
 		const keys: Key[] = [];
@@ -71,8 +67,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/repositoryFilter.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema, SchemaIssue } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient } from "effect/sql";
+import { SqlClient } from "effect/sql";
 import { type TupleFilter, tuplePredicate } from "#tupleIn.ts";
 
 export type RepositoryFilter<TModel extends Model.Any> = {
@@ -34,7 +34,8 @@ function isOperator(key: string): key is keyof typeof operators {
 	return Object.hasOwn(operators, key);
 }
 
-export function makeFilter<TModel extends Model.Any>(model: TModel, sql: SqlClient.SqlClient, references?: { readonly tableName: string }) {
+export const makeFilter = Effect.fnUntraced(function* <TModel extends Model.Any>(model: TModel, references?: { readonly tableName: string }) {
+	const sql = yield* SqlClient.SqlClient;
 	function fieldAt(key: string) {
 		const field = Object.hasOwn(model.fields, key) ? model.fields[key] : undefined;
 		return field === undefined
@@ -105,7 +106,7 @@ export function makeFilter<TModel extends Model.Any>(model: TModel, sql: SqlClie
 				([key, value]) => predicate(key, value, allowIn, allowComparisons),
 			);
 			if (allowIn) {
-				const tuple = yield* tuplePredicate(input, sql, fieldAt);
+				const tuple = yield* tuplePredicate(input, fieldAt).pipe(Effect.provideService(SqlClient.SqlClient, sql));
 				if (tuple !== undefined) {
 					predicates.push(tuple);
 				}
@@ -114,4 +115,4 @@ export function makeFilter<TModel extends Model.Any>(model: TModel, sql: SqlClie
 		});
 	}
 	return { fieldAt, where };
-}
+});

package/src/repositoryQueries.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient } from "effect/sql";
+import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import type { Fragment } from "effect/sql/Statement";
 import type { Aggregate } from "#aggregateQuery.ts";
@@ -46,62 +46,64 @@ export interface Queries<TModel extends Model.Any> {
 
 export function makeQueries<TModel extends Model.Any>(
 	model: TModel,
-	sql: SqlClient.SqlClient,
 	options: {
 		readonly tableName: string;
 		readonly spanPrefix: string;
 	},
-): Queries<TModel> {
-	const { fieldAt, where } = makeFilter(model, sql);
-	const readLatest = makeLatestPerGroup(model, sql, options.tableName);
-	const { decodeLimit, orderClause, limitClause } = makeQueryClauses(sql, fieldAt);
-	const aggregate = makeAggregate(model, sql, options);
-	function count(query?: Pick<FindMany<TModel, Key<TModel>>, "where">): ReturnType<Queries<TModel>["count"]>;
-	function count(query: Pick<FindMany<TModel, Key<TModel>>, "where"> = {}): Effect.Effect<number, SqlError | Schema.SchemaError, unknown> {
-		return Effect.gen(function* () {
-			const predicate = yield* where(query.where, true, true);
-			const rows = yield* sql`select cast(count(*) as text) as count from ${sql(options.tableName)} where ${predicate}`;
-			const [result] = yield* Schema.decodeUnknownEffect(CountResult)(rows);
-			return result.count;
-		}).pipe(Effect.withSpan(`${options.spanPrefix}.count`));
-	}
-	function select<TKey extends Key<TModel> = Key<TModel>>(
-		query?: FindMany<TModel, TKey>,
-	): RepositorySelect<Pick<TModel["fields"], TKey>, TModel["fields"][Key<TModel>]["EncodingServices"]>;
-	function select(query: FindMany<TModel, Key<TModel>> = {}): RepositorySelect<Schema.Struct.Fields, unknown> {
-		const keys = query.select ?? Object.keys(model.fields);
-		const fields = Object.fromEntries(keys.map((key) => [key, model.fields[key]]));
-		const statement = Effect.gen(function* () {
-			yield* Effect.forEach(keys, fieldAt);
-			const predicate = yield* where(query.where, true, true);
-			const order = yield* orderClause(query.orderBy);
-			const limit = yield* limitClause(query.limit);
-			return sql`select ${sql.csv(keys.map((key) => sql`${sql(key)}`))} from ${sql(options.tableName)} where ${predicate} ${order} ${limit}`;
-		});
-		return { fields, statement };
-	}
-	function findMany<TKey extends Key<TModel> = Key<TModel>>(
-		query?: FindMany<TModel, TKey>,
-	): Effect.Effect<
-		Pick<Row<TModel>, TKey>[],
-		SqlError | Schema.SchemaError,
-		TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][TKey]["DecodingServices"]
-	>;
-	// Object.fromEntries erases the selected key-to-schema correspondence, so the typed overload restates it.
-	function findMany(query: FindMany<TModel, Key<TModel>> = {}): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> {
-		return Effect.gen(function* () {
-			const selected = select(query);
-			const rows = yield* sql`${yield* selected.statement}`;
-			return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(selected.fields)))(rows);
-		}).pipe(Effect.withSpan(`${options.spanPrefix}.findMany`));
-	}
-	function latestPerGroup(query: LatestPerGroup<TModel>): ReturnType<Queries<TModel>["latestPerGroup"]>;
-	function latestPerGroup(query: LatestPerGroup<TModel>): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> {
-		return Effect.gen(function* () {
-			const order = yield* orderClause(query.orderBy);
-			const rowLimit = yield* decodeLimit(query.limit);
-			return yield* readLatest(query, order, rowLimit);
-		}).pipe(Effect.withSpan(`${options.spanPrefix}.latestPerGroup`));
-	}
-	return { aggregate, count, findMany, latestPerGroup, select };
+): Effect.Effect<Queries<TModel>, never, SqlClient.SqlClient> {
+	return Effect.fnUntraced(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const { fieldAt, where } = yield* makeFilter(model);
+		const readLatest = yield* makeLatestPerGroup(model, options.tableName);
+		const { decodeLimit, orderClause, limitClause } = yield* makeQueryClauses(fieldAt);
+		const aggregate = yield* makeAggregate(model, options);
+		function count(query?: Pick<FindMany<TModel, Key<TModel>>, "where">): ReturnType<Queries<TModel>["count"]>;
+		function count(query: Pick<FindMany<TModel, Key<TModel>>, "where"> = {}): Effect.Effect<number, SqlError | Schema.SchemaError, unknown> {
+			return Effect.gen(function* () {
+				const predicate = yield* where(query.where, true, true);
+				const rows = yield* sql`select cast(count(*) as text) as count from ${sql(options.tableName)} where ${predicate}`;
+				const [result] = yield* Schema.decodeUnknownEffect(CountResult)(rows);
+				return result.count;
+			}).pipe(Effect.withSpan(`${options.spanPrefix}.count`));
+		}
+		function select<TKey extends Key<TModel> = Key<TModel>>(
+			query?: FindMany<TModel, TKey>,
+		): RepositorySelect<Pick<TModel["fields"], TKey>, TModel["fields"][Key<TModel>]["EncodingServices"]>;
+		function select(query: FindMany<TModel, Key<TModel>> = {}): RepositorySelect<Schema.Struct.Fields, unknown> {
+			const keys = query.select ?? Object.keys(model.fields);
+			const fields = Object.fromEntries(keys.map((key) => [key, model.fields[key]]));
+			const statement = Effect.gen(function* () {
+				yield* Effect.forEach(keys, fieldAt);
+				const predicate = yield* where(query.where, true, true);
+				const order = yield* orderClause(query.orderBy);
+				const limit = yield* limitClause(query.limit);
+				return sql`select ${sql.csv(keys.map((key) => sql`${sql(key)}`))} from ${sql(options.tableName)} where ${predicate} ${order} ${limit}`;
+			});
+			return { fields, statement };
+		}
+		function findMany<TKey extends Key<TModel> = Key<TModel>>(
+			query?: FindMany<TModel, TKey>,
+		): Effect.Effect<
+			Pick<Row<TModel>, TKey>[],
+			SqlError | Schema.SchemaError,
+			TModel["fields"][Key<TModel>]["EncodingServices"] | TModel["fields"][TKey]["DecodingServices"]
+		>;
+		// Object.fromEntries erases the selected key-to-schema correspondence, so the typed overload restates it.
+		function findMany(query: FindMany<TModel, Key<TModel>> = {}): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> {
+			return Effect.gen(function* () {
+				const selected = select(query);
+				const rows = yield* sql`${yield* selected.statement}`;
+				return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(selected.fields)))(rows);
+			}).pipe(Effect.withSpan(`${options.spanPrefix}.findMany`));
+		}
+		function latestPerGroup(query: LatestPerGroup<TModel>): ReturnType<Queries<TModel>["latestPerGroup"]>;
+		function latestPerGroup(query: LatestPerGroup<TModel>): Effect.Effect<unknown, SqlError | Schema.SchemaError, unknown> {
+			return Effect.gen(function* () {
+				const order = yield* orderClause(query.orderBy);
+				const rowLimit = yield* decodeLimit(query.limit);
+				return yield* readLatest(query, order, rowLimit);
+			}).pipe(Effect.withSpan(`${options.spanPrefix}.latestPerGroup`));
+		}
+		return { aggregate, count, findMany, latestPerGroup, select };
+	})();
 }