@shivaedev/sql 0.34.0 → 0.36.1

package/src/latestPerGroup.ts

@@ -18,8 +18,9 @@ function groupMasks(input: readonly (readonly unknown[])[]) {
 	return [...masks.values()];
 }
 
-export function latestPerGroup(model: Model.Any, sql: SqlClient.SqlClient, tableName: string) {
-	const { fieldAt, where } = makeFilter(model, sql);
+export const latestPerGroup = Effect.fnUntraced(function* (model: Model.Any, tableName: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const { fieldAt, where } = yield* makeFilter(model);
 	function groupSource(groups: readonly (readonly unknown[])[], partitionBy: readonly string[], fromTuple: boolean) {
 		const partitions = sql.csv(partitionBy.map((key) => sql`${sql(key)}`));
 		if (fromTuple) {
@@ -37,7 +38,7 @@ export function latestPerGroup(model: Model.Any, sql: SqlClient.SqlClient, table
 		const partitions = sql.csv(query.partitionBy.map((key) => sql`${sql(key)}`));
 		const keys = Object.keys(model.fields);
 		const columns = sql.csv(keys.map((key) => sql`${sql(key)}`));
-		const pinned = yield* pinnedGroups(model, sql, query.partitionBy, query.where);
+		const pinned = yield* pinnedGroups(model, query.partitionBy, query.where).pipe(Effect.provideService(SqlClient.SqlClient, sql));
 		if (pinned !== undefined && pinned.groups.length === 0) {
 			return [];
 		}
@@ -82,4 +83,4 @@ export function latestPerGroup(model: Model.Any, sql: SqlClient.SqlClient, table
 		order by ${partitions}, ${sql(rankColumn)}`;
 		return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(model.fields)))(rows);
 	});
-}
+});

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 { 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) {
@@ -95,4 +95,4 @@ export function makeConflictClause(
 		});
 	}
 	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/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/releaseWorkers.ts

@@ -1,5 +1,6 @@
-import { Effect, Random, Schema } from "effect";
+import { Clock, Effect, Option, Random, Schema } from "effect";
 import { SqlClient } from "effect/sql";
+import { WorkerReleaseTesting } from "#testing/WorkerRelease.ts";
 
 export const releaseWorkers = Effect.fn("EffectSql.releaseWorkers")(function* (
 	release: string,
@@ -9,9 +10,17 @@ export const releaseWorkers = Effect.fn("EffectSql.releaseWorkers")(function* (
 	const sql = yield* SqlClient.SqlClient;
 	const processId = `${yield* Random.nextInt}:${yield* Random.nextInt}`;
 	const workers = `${table}_workers`;
+	const testing = yield* Effect.serviceOption(WorkerReleaseTesting);
+	const now = Option.isSome(testing)
+		? Clock.currentTimeMillis.pipe(
+				Effect.provideService(Clock.Clock, testing.value.clock),
+				Effect.map((millis) => sql`${new Date(millis).toISOString()}::timestamptz`),
+			)
+		: Effect.succeed(sql`clock_timestamp()`);
 	return {
 		claim: sql.withTransaction(
 			Effect.gen(function* () {
+				const timestamp = yield* now;
 				const [owner] = yield* sql`select release from ${sql(`${table}_release`)} where id = true for update`.withoutTransform.pipe(
 					Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ release: Schema.String })))),
 				);
@@ -19,16 +28,19 @@ export const releaseWorkers = Effect.fn("EffectSql.releaseWorkers")(function* (
 					return false;
 				}
 				const others = yield* sql`select process_id from ${sql(workers)} where release <> ${release}
-				and heartbeat > clock_timestamp() - ${staleMillis} * interval '1 millisecond'`;
+				and heartbeat > ${timestamp} - ${staleMillis} * interval '1 millisecond'`;
 				if (others.length > 0) {
 					return false;
 				}
-				yield* sql`insert into ${sql(workers)} (process_id, release, heartbeat) values (${processId}, ${release}, clock_timestamp())
+				yield* sql`insert into ${sql(workers)} (process_id, release, heartbeat) values (${processId}, ${release}, ${timestamp})
 				on conflict (process_id) do update set heartbeat = excluded.heartbeat`;
 				return true;
 			}),
 		),
-		heartbeat: sql`update ${sql(workers)} set heartbeat = clock_timestamp() where process_id = ${processId}`.pipe(Effect.asVoid),
+		heartbeat: now.pipe(
+			Effect.flatMap((timestamp) => sql`update ${sql(workers)} set heartbeat = ${timestamp} where process_id = ${processId}`),
+			Effect.asVoid,
+		),
 		remove: sql`delete from ${sql(workers)} where process_id = ${processId}`.pipe(Effect.asVoid),
 	};
 });

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

@@ -8,12 +8,8 @@ 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[] = [];

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 };
+	})();
 }

package/src/repositoryWrites.ts

@@ -1,18 +1,18 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
-import { type SqlClient, SqlSchema } from "effect/sql";
-import type { RepositoryChanges } from "./repositoryChanges.ts";
-import { makeFilter } from "./repositoryFilter.ts";
-import { selectedUpdate } from "./repositoryUpdate.ts";
+import { SqlClient, SqlSchema } from "effect/sql";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
+import { makeFilter } from "#repositoryFilter.ts";
+import { selectedUpdate } from "#repositoryUpdate.ts";
 
-export function repositoryWrites(
+export const repositoryWrites = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: { readonly idColumns: readonly string[]; readonly tableName: string; readonly spanPrefix: string },
 	changes: RepositoryChanges,
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	const { idColumns, tableName, spanPrefix } = options;
-	const { where } = makeFilter(model, sql);
+	const { where } = yield* makeFilter(model);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const filterRecord = Schema.decodeUnknownEffect(Schema.Record(Schema.PropertyKey, Schema.Unknown));
 	function predicate(input: Readonly<Record<string, unknown>>) {
@@ -49,7 +49,7 @@ export function repositoryWrites(
 	const idColumn = idColumns[0] ?? "";
 	const key = model.fields[idColumn];
 	if (key === undefined) {
-		throw new Error("Unknown repository ID column");
+		return yield* Effect.die(new Error("Unknown repository ID column"));
 	}
 	const isKey = Schema.is(key);
 	const removeByKey = SqlSchema.void({
@@ -84,4 +84,4 @@ export function repositoryWrites(
 				.write(settings === undefined ? updateVoid(input) : selected(input, settings.columns, false))
 				.pipe(Effect.withSpan(`${spanPrefix}.updateVoid`)),
 	};
-}
+});

package/src/testing/WorkerRelease.ts

@@ -0,0 +1,13 @@
+import { type Clock, Context, type Effect, type Schema, type Scope } from "effect";
+import type { SqlError } from "effect/sql/SqlError";
+
+export class WorkerReleaseTesting extends Context.Service<
+	WorkerReleaseTesting,
+	{
+		readonly clock: Clock.Clock;
+		readonly register: (tick: {
+			readonly heartbeat: Effect.Effect<void, SqlError | Schema.SchemaError>;
+			readonly poll: Effect.Effect<void, SqlError | Schema.SchemaError>;
+		}) => Effect.Effect<void, never, Scope.Scope>;
+	}
+>()("@shivaedev/sql/testing/WorkerReleaseTesting") {}