@shivaedev/sql 0.34.0 → 0.35.0

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

@@ -51,27 +51,25 @@ export function tupleIn<TModel extends Model.Any, const TFields extends readonly
 	return { [tupleFilter]: { fields, model, types: fields.map((field: TFields[number]) => types[field]), values } };
 }
 
-export function tuplePredicate(
+export const tuplePredicate = Effect.fnUntraced(function* (
 	input: Partial<TupleFilter<Model.Any>>,
-	sql: SqlClient.SqlClient,
 	fieldAt: (key: string) => Effect.Effect<Schema.Constraint, Schema.SchemaError>,
 ) {
 	const tuple = input[tupleFilter];
 	if (tuple === undefined) {
-		return Effect.succeed(undefined);
+		return undefined;
 	}
-	return Effect.gen(function* () {
-		const fields = yield* Effect.forEach(tuple.fields, fieldAt);
-		const encode = Schema.encodeUnknownEffect(Schema.Tuple(fields));
-		const columns = sql.csv(tuple.fields.map((field) => sql`${sql(field)}`));
-		const rows: readonly (readonly unknown[])[] = yield* Effect.forEach(tuple.values, (value) => encode(value));
-		if (rows.length === 0) {
-			return sql`1 = 0`;
-		}
-		if (sql.onDialectOrElse({ orElse: () => false, pg: () => true })) {
-			const relation = yield* tupleUnnest(tuple.types, rows).pipe(Effect.provideService(SqlClient.SqlClient, sql));
-			return sql`(${columns}) in (select * from ${relation})`;
-		}
-		return sql.or(rows.map((row) => sql`(${columns}) = (${sql.csv(row.map((entry) => sql`${entry}`))})`));
-	});
-}
+	const sql = yield* SqlClient.SqlClient;
+	const fields = yield* Effect.forEach(tuple.fields, fieldAt);
+	const encode = Schema.encodeUnknownEffect(Schema.Tuple(fields));
+	const columns = sql.csv(tuple.fields.map((field) => sql`${sql(field)}`));
+	const rows: readonly (readonly unknown[])[] = yield* Effect.forEach(tuple.values, (value) => encode(value));
+	if (rows.length === 0) {
+		return sql`1 = 0`;
+	}
+	if (sql.onDialectOrElse({ orElse: () => false, pg: () => true })) {
+		const relation = yield* tupleUnnest(tuple.types, rows).pipe(Effect.provideService(SqlClient.SqlClient, sql));
+		return sql`(${columns}) in (select * from ${relation})`;
+	}
+	return sql.or(rows.map((row) => sql`(${columns}) = (${sql.csv(row.map((entry) => sql`${entry}`))})`));
+});

package/src/upsertResult.ts

@@ -1,15 +1,16 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient } from "effect/sql";
+import { SqlClient } from "effect/sql";
 
 export interface UpsertRow<TRow> {
 	readonly inserted: boolean;
 	readonly row: TRow;
 }
 
-export function upsertReturning(sql: SqlClient.SqlClient) {
+export const upsertReturning = Effect.fnUntraced(function* () {
+	const sql = yield* SqlClient.SqlClient;
 	return sql`*, (xmax = 0) as ${sql("effectSqlInserted")}`;
-}
+});
 
 export function makeUpsertDecoder(model: Model.Any) {
 	const decode = Schema.decodeUnknownEffect(model);

package/src/versionedRepository.ts

@@ -1,12 +1,12 @@
 import { Effect, Option, Schema } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient, SqlModel } from "effect/sql";
+import { SqlClient, type SqlModel } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import type { PrimaryKey, Repository } from "#compositeRepository.ts";
 import type { OptimisticConcurrencyError } from "#repository.ts";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
 import type { UpdateInput } from "#repositoryUpdate.ts";
 import { type VersionedOptions, versionedStatements } from "#versionedStatements.ts";
-import type { RepositoryChanges } from "./repositoryChanges.ts";
 
 export type IdColumn<TModel extends Model.Any> = keyof TModel["Type"] & keyof TModel["update"]["Type"] & keyof TModel["fields"];
 export type VersionColumn<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = {
@@ -43,13 +43,13 @@ export interface VersionedWrites<TModel extends Model.Any, TId extends PrimaryKe
 	readonly updateVoid: (input: UpdateInput<TModel>) => Effect.Effect<void, WriteError, TModel["update"]["EncodingServices"]>;
 }
 
-export function makeVersionedWrites(
+export const makeVersionedWrites = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: VersionedOptions & { readonly changes: RepositoryChanges; readonly spanPrefix: string },
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	const { spanPrefix, changes } = options;
-	const statements = versionedStatements(model, sql, options);
+	const statements = yield* versionedStatements(model, options);
 	const decodeRow = Schema.decodeUnknownEffect(model);
 	function insert(input: unknown) {
 		return Effect.gen(function* () {
@@ -106,4 +106,4 @@ export function makeVersionedWrites(
 		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.delete`));
 	}
 	return { delete: deleteRow, insert, insertVoid, update, updateVoid, ...(options.conflictColumns === undefined ? {} : { insertOrIgnore }) };
-}
+});

package/src/versionedStatements.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 { makeConflictClause } from "#makeConflictClause.ts";
 import type { OptimisticConcurrencyError } from "#repository.ts";
 
@@ -14,21 +14,21 @@ export interface VersionedOptions {
 	readonly versionColumn: string;
 }
 
-export function versionedStatements(model: Model.Any, sql: SqlClient.SqlClient, options: VersionedOptions) {
+export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any, options: VersionedOptions) {
+	const sql = yield* SqlClient.SqlClient;
 	const { tableName, idColumns, versionColumn, conflict } = options;
-	const fields = Object.fromEntries(
-		idColumns.map((column) => {
-			const field = model.fields[column];
-			if (field === undefined) {
-				throw new Error(`Unknown ID column: ${column}`);
-			}
-			return [column, field];
-		}),
-	);
-	const encodeKey = Schema.encodeEffect(Schema.Struct(fields));
+	const entries: [string, Schema.Constraint][] = [];
+	for (const column of idColumns) {
+		const field = model.fields[column];
+		if (field === undefined) {
+			return yield* Effect.die(new Error(`Unknown ID column: ${column}`));
+		}
+		entries.push([column, field]);
+	}
+	const encodeKey = Schema.encodeEffect(Schema.Struct(Object.fromEntries(entries)));
 	const versionSchema = model.fields[versionColumn];
 	if (versionSchema === undefined) {
-		throw new Error(`Unknown version column: ${versionColumn}`);
+		return yield* Effect.die(new Error(`Unknown version column: ${versionColumn}`));
 	}
 	const encodeVersion = Schema.encodeEffect(versionSchema);
 	const encodeInsert = Schema.encodeEffect(model.insert);
@@ -36,7 +36,7 @@ export function versionedStatements(model: Model.Any, sql: SqlClient.SqlClient,
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const validateVersion = Schema.decodeUnknownEffect(Version);
 	const clause =
-		options.conflictColumns === undefined ? undefined : makeConflictClause(model, sql, { ...options, conflictColumns: options.conflictColumns });
+		options.conflictColumns === undefined ? undefined : yield* makeConflictClause(model, { ...options, conflictColumns: options.conflictColumns });
 	function key(input: unknown) {
 		return idColumns.length === 1 ? { [idColumns[0] ?? ""]: input } : input;
 	}
@@ -86,4 +86,4 @@ export function versionedStatements(model: Model.Any, sql: SqlClient.SqlClient,
 		});
 	}
 	return { insert, remove, update };
-}
+});

package/dist/testing.d.ts

@@ -1,27 +0,0 @@
-import { Effect, Schema } from "effect";
-import { SqlClient } from "effect/sql";
-import { type BucketKey, type ItemKey } from "@shivaedev/changes/keys.ts";
-declare const UnannouncedWrites_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "UnannouncedWrites";
-} & Readonly<A>;
-export declare class UnannouncedWrites extends UnannouncedWrites_base<{
-    readonly tables: readonly string[];
-}> {
-}
-export interface ChangeCoverage {
-    readonly covers: Readonly<Record<string, readonly (ItemKey | BucketKey)[]>>;
-}
-export declare const withChangeCoverage: <A, E, R>(body: Effect.Effect<A, E, R>, options?: ChangeCoverage | undefined) => Effect.Effect<A, Schema.SchemaError | import("effect/sql/SqlError").SqlError | UnannouncedWrites | Exclude<E, import("effect/sql/SqlError").SqlError>, import("effect/reactivity/Reactivity").Reactivity | SqlClient.SqlClient | Exclude<Exclude<R, never>, never>>;
-declare const PublishedKeysMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "PublishedKeysMismatch";
-} & Readonly<A>;
-export declare class PublishedKeysMismatch extends PublishedKeysMismatch_base<{
-    readonly expected: readonly unknown[];
-    readonly actual: readonly unknown[];
-}> {
-    get message(): string;
-}
-export declare function expectPublished(keys: readonly unknown[]): <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | PublishedKeysMismatch, R>;
-export declare function expectPublished<A>(keys: (result: A) => readonly unknown[]): <E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | PublishedKeysMismatch, R>;
-export {};
-//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,OAAO,EAAoB,MAAM,4BAA4B,CAAC;;;;AAI5F,qBAAa,iBAAkB,SAAQ,uBAAsC;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;CAAG;AAEvH,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;CAC5E;AAED,eAAO,MAAM,kBAAkB,GAAsD,CAAC,EAAE,CAAC,EAAE,CAAC,4UAuD1F,CAAC;;;;AAEH,qBAAa,qBAAsB,SAAQ,2BAA0C;IACpF,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC,CAAC;IACD,IAAa,OAAO,WAEnB;CACD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,qBAAqB,EAAE,CAAC,CAAC,CAAC;AACrJ,wBAAgB,eAAe,CAAC,CAAC,EAChC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,SAAS,OAAO,EAAE,GACrC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,qBAAqB,EAAE,CAAC,CAAC,CAAC"}

package/dist/testing.js

@@ -1,75 +0,0 @@
-import { Data, Effect, Schema } from "effect";
-import { SqlClient } from "effect/sql";
-import { invalidationKeys } from "@shivaedev/changes/keys.ts";
-import { ChangeDeclarations } from "#ChangeDeclarations.ts";
-import { ChangeObserver, transact } from "#transact.ts";
-export class UnannouncedWrites extends Data.TaggedError("UnannouncedWrites") {
-}
-export const withChangeCoverage = Effect.fn("Changes.withChangeCoverage")(function* (body, options) {
-    const observer = yield* ChangeObserver;
-    const sql = yield* SqlClient.SqlClient;
-    const named = new Set();
-    const declarations = new Map();
-    const outer = yield* ChangeDeclarations;
-    const written = sql `select relid, relname, (n_tup_ins + n_tup_upd + n_tup_del)::int as writes from pg_stat_xact_user_tables`.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ relid: Schema.Int, relname: Schema.String, writes: Schema.Int })))));
-    const checked = Effect.gen(function* () {
-        const before = new Map((yield* written).map((row) => [row.relid, row.writes]));
-        const result = yield* body;
-        const missing = (yield* written).filter((row) => {
-            const count = row.writes - (before.get(row.relid) ?? 0);
-            if (count <= 0) {
-                return false;
-            }
-            const automatic = declarations.get(row.relname);
-            const explicit = options?.covers[row.relname] ?? [];
-            const expected = [...(automatic?.keys ?? []), ...invalidationKeys(explicit)];
-            return (count > (automatic?.rows ?? 0) && explicit.length === 0) || expected.some((key) => !named.has(key));
-        });
-        if (missing.length > 0) {
-            return yield* Effect.fail(new UnannouncedWrites({ tables: missing.map((row) => row.relname).sort() }));
-        }
-        return result;
-    });
-    return yield* checked.pipe(transact({ onSqlError: (error) => error }), Effect.provideService(ChangeDeclarations, {
-        declare: (table, keys, rows) => Effect.andThen(Effect.sync(() => {
-            const entry = declarations.get(table) ?? { keys: new Set(), rows: 0 };
-            for (const key of keys) {
-                entry.keys.add(key);
-            }
-            entry.rows += rows;
-            declarations.set(table, entry);
-        }), outer.declare(table, keys, rows)),
-    }), Effect.provideService(ChangeObserver, (event) => {
-        if (event._tag === "Recorded") {
-            for (const key of event.changes) {
-                named.add(key);
-            }
-        }
-        return observer(event);
-    }));
-});
-export class PublishedKeysMismatch extends Data.TaggedError("PublishedKeysMismatch") {
-    get message() {
-        return `Expected published keys ${JSON.stringify(this.expected)}; actual published keys ${JSON.stringify(this.actual)}`;
-    }
-}
-export function expectPublished(keys) {
-    return Effect.fn("Changes.expectPublished")(function* (body) {
-        const observer = yield* ChangeObserver;
-        const actual = new Set();
-        const result = yield* body.pipe(Effect.provideService(ChangeObserver, (event) => {
-            if (event._tag === "Published") {
-                for (const key of event.changes) {
-                    actual.add(key);
-                }
-            }
-            return observer(event);
-        }));
-        const expected = new Set(typeof keys === "function" ? keys(result) : keys);
-        if (actual.size !== expected.size || [...expected].some((key) => !actual.has(key))) {
-            return yield* Effect.fail(new PublishedKeysMismatch({ actual: [...actual], expected: [...expected] }));
-        }
-        return result;
-    });
-}
-//# sourceMappingURL=testing.js.map