@shivaedev/sql 0.0.0 → 0.21.0

package/src/compositeRepository.ts

@@ -0,0 +1,101 @@
+import type { Cause } from "effect";
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import { type SqlClient, SqlSchema } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import { type RepositoryChanges, repositoryChanges } from "#repositoryChanges.ts";
+import type { RepositoryListFilter } from "#repositoryFilter.ts";
+import { repositoryWrites } from "#repositoryWrites.ts";
+import type { IdColumn, NativeRepository } from "#versionedRepository.ts";
+
+export type CompositeKey<TModel extends Model.Any> = readonly [IdColumn<TModel>, IdColumn<TModel>, ...IdColumn<TModel>[]];
+export type PrimaryKey<TModel extends Model.Any> = IdColumn<TModel> | CompositeKey<TModel>;
+type DeleteWhere<TModel extends Model.Any> = (
+	where: RepositoryListFilter<TModel>,
+) => Effect.Effect<void, SqlError | Schema.SchemaError, TModel["fields"][keyof TModel["fields"]]["EncodingServices"]>;
+
+interface Update<TModel extends Model.Any> {
+	(
+		input: TModel["update"]["Type"],
+		options: { readonly onMissing: "fail" },
+	): Effect.Effect<
+		TModel["Type"],
+		SqlError | Schema.SchemaError | Cause.NoSuchElementError,
+		TModel["update"]["EncodingServices"] | TModel["DecodingServices"]
+	>;
+	(
+		input: TModel["update"]["Type"],
+	): Effect.Effect<TModel["Type"], SqlError | Schema.SchemaError, TModel["update"]["EncodingServices"] | TModel["DecodingServices"]>;
+}
+
+export type Repository<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = [TId] extends [IdColumn<TModel>]
+	? Omit<NativeRepository<TModel, Extract<TId, IdColumn<TModel>>>, "delete" | "update"> & {
+			readonly delete: NativeRepository<TModel, Extract<TId, IdColumn<TModel>>>["delete"] & DeleteWhere<TModel>;
+			readonly update: Update<TModel>;
+		}
+	: TId extends CompositeKey<TModel>
+		? Omit<NativeRepository<TModel, TId[number]>, "findById" | "delete" | "update"> & {
+				readonly update: Update<TModel>;
+				readonly findById: (
+					id: Pick<TModel["Type"], TId[number]>,
+				) => Effect.Effect<
+					TModel["Type"],
+					SqlError | Schema.SchemaError | Cause.NoSuchElementError,
+					TModel["DecodingServices"] | TModel["fields"][TId[number]]["EncodingServices"]
+				>;
+				readonly delete: ((
+					id: Pick<TModel["Type"], TId[number]>,
+				) => Effect.Effect<void, SqlError | Schema.SchemaError, TModel["fields"][TId[number]]["EncodingServices"]>) &
+					DeleteWhere<TModel>;
+			}
+		: never;
+
+export function makeCompositeCrud(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: {
+		readonly columns: readonly string[];
+		readonly tableName: string;
+		readonly spanPrefix: string;
+	},
+	supplied?: RepositoryChanges,
+) {
+	const { columns, tableName, spanPrefix } = options;
+	const fields = Object.fromEntries(
+		columns.map((column) => {
+			const field = model.fields[column];
+			if (field === undefined) {
+				throw new Error(`Unknown ID column: ${column}`);
+			}
+			return [column, field];
+		}),
+	);
+	const Key = columns.length === 1 ? model.fields[columns[0] ?? ""] : Schema.Struct(fields);
+	if (Key === undefined) {
+		throw new Error("Unknown repository ID column");
+	}
+	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+	function predicate(input: Readonly<Record<string, unknown>>) {
+		return sql.and(columns.map((column) => sql`${sql(column)} = ${input[column]}`));
+	}
+	const find = SqlSchema.findOne({
+		execute: (input) =>
+			Effect.flatMap(
+				record(columns.length === 1 ? { [columns[0] ?? ""]: input } : input),
+				(key) => sql`select * from ${sql(tableName)} where ${predicate(key)}`,
+			),
+		Request: Key,
+		Result: model,
+	});
+	const changes = supplied ?? {
+		record: (rows: readonly Readonly<Record<string, unknown>>[]) =>
+			Effect.flatMap(repositoryChanges(sql, tableName, columns), (boundary) => boundary.record(rows)),
+		write<A, E, R>(effect: Effect.Effect<A, E, R>) {
+			return Effect.flatMap(repositoryChanges(sql, tableName, columns), (boundary) => boundary.write(effect));
+		},
+	};
+	return {
+		...repositoryWrites(model, sql, { ...options, idColumns: columns }, changes),
+		findById: (id: unknown) => find(id).pipe(Effect.withSpan(`${spanPrefix}.findById`)),
+	};
+}

package/src/conditionalUpsert.ts

@@ -0,0 +1,97 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import { makeConflictClause } from "#makeConflictClause.ts";
+import type { Comparisons, FindManyFilter } from "#repositoryFilter.ts";
+import type { RepositoryChanges } from "./repositoryChanges.ts";
+
+type Fields<TModel extends Model.Any> = Schema.Struct.Type<TModel["fields"]>;
+interface Incoming<TModel extends Model.Any, TValue> {
+	readonly excluded: {
+		[TKey in keyof Fields<TModel>]: [Fields<TModel>[TKey]] extends [TValue] ? TKey : never;
+	}[keyof Fields<TModel>];
+}
+export type UpsertFilter<TModel extends Model.Any> = {
+	readonly [TKey in keyof Fields<TModel>]?:
+		| FindManyFilter<TModel>[TKey]
+		| Incoming<TModel, Fields<TModel>[TKey]>
+		| Comparisons<Fields<TModel>[TKey], NonNullable<Fields<TModel>[TKey]> | Incoming<TModel, NonNullable<Fields<TModel>[TKey]>>>;
+};
+export type UpsertResult<TRow> =
+	| { readonly _tag: "Inserted"; readonly row: TRow }
+	| { readonly _tag: "Updated"; readonly row: TRow }
+	| { readonly _tag: "Unchanged" };
+export interface ConditionalUpsert<TModel extends Model.Any, TOptions, TServices> {
+	(
+		input: TModel["insert"]["Type"],
+		options: TOptions & { readonly updateWhere: UpsertFilter<TModel> },
+	): Effect.Effect<
+		UpsertResult<TModel["Type"]>,
+		SqlError | Schema.SchemaError,
+		TServices | TModel["fields"][keyof TModel["fields"]]["EncodingServices"]
+	>;
+	(
+		input: TModel["insert"]["Type"],
+		options: TOptions & { readonly updateWhere?: never },
+	): Effect.Effect<TModel["Type"], SqlError | Schema.SchemaError, TServices>;
+}
+export interface ConditionalUpsertMany<TModel extends Model.Any, TOptions, TServices> {
+	(
+		inputs: readonly TModel["insert"]["Type"][],
+		options: TOptions & { readonly updateWhere: UpsertFilter<TModel> },
+	): Effect.Effect<
+		UpsertResult<TModel["Type"]>[],
+		SqlError | Schema.SchemaError,
+		TServices | TModel["fields"][keyof TModel["fields"]]["EncodingServices"]
+	>;
+	(
+		inputs: readonly TModel["insert"]["Type"][],
+		options: TOptions & { readonly updateWhere?: never },
+	): Effect.Effect<TModel["Type"][], SqlError | Schema.SchemaError, TServices>;
+}
+
+export function makeConditionalUpsert(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: {
+		readonly tableName: string;
+		readonly spanPrefix: string;
+		readonly changes: RepositoryChanges;
+		readonly conflictColumns: readonly string[];
+		readonly conflictWhere?: Readonly<Record<string, unknown>>;
+		readonly idColumns: readonly string[];
+	},
+) {
+	const encode = Schema.encodeEffect(model.insert);
+	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+	const decode = Schema.decodeUnknownEffect(model);
+	const clause = makeConflictClause(model, sql, options);
+	return (
+		inputs: readonly unknown[],
+		settings: { readonly updateColumns: readonly string[]; readonly updateWhere: Readonly<Record<string, unknown>> },
+	) =>
+		Effect.gen(function* () {
+			const statements = yield* Effect.forEach(inputs, (input) =>
+				Effect.gen(function* () {
+					const row = yield* record(yield* encode(input));
+					const suffix = yield* clause(row, settings.updateColumns, settings.updateWhere);
+					return sql`insert into ${sql(options.tableName)} ${sql.insert(row)} ${suffix} returning *, (xmax = 0) as ${sql("effectSqlInserted")}`;
+				}),
+			);
+			const changedRows: Readonly<Record<string, unknown>>[] = [];
+			const results = yield* Effect.forEach(statements, (statement) =>
+				Effect.gen(function* () {
+					const rows = yield* statement;
+					changedRows.push(...rows);
+					const row = rows[0];
+					if (row === undefined) {
+						return { _tag: "Unchanged" } as const;
+					}
+					return { _tag: row.effectSqlInserted ? "Inserted" : "Updated", row: yield* decode(row) } as const;
+				}),
+			);
+			yield* options.changes.record(changedRows);
+			return results;
+		}).pipe(options.changes.write, Effect.withSpan(`${options.spanPrefix}.conditionalUpsert`));
+}

package/src/conflictWrites.ts

@@ -0,0 +1,93 @@
+import { Effect, Option, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import { type InsertMany, makeInsertMany } from "#batchWrites.ts";
+import { type ConditionalUpsert, type ConditionalUpsertMany, makeConditionalUpsert } from "#conditionalUpsert.ts";
+import { type InsertFromSelect, makeInsertFromSelect } from "#insertFromSelect.ts";
+import { makeConflictClause } from "#makeConflictClause.ts";
+import type { RepositoryChanges } from "./repositoryChanges.ts";
+
+export type InsertColumn<TModel extends Model.Any> = Extract<keyof TModel["insert"]["Type"] & keyof TModel["fields"], string>;
+export type ConflictColumns<TModel extends Model.Any> = readonly [InsertColumn<TModel>, ...InsertColumn<TModel>[]];
+interface UpdateOptions<TModel extends Model.Any, TExcluded extends PropertyKey> {
+	readonly updateColumns: readonly [
+		Exclude<InsertColumn<TModel> & keyof TModel["update"]["Type"], TExcluded>,
+		...Exclude<InsertColumn<TModel> & keyof TModel["update"]["Type"], TExcluded>[],
+	];
+}
+export interface ConflictWrites<TModel extends Model.Any, TExcluded extends PropertyKey, TFilterServices = never> {
+	readonly insertFromSelectOrIgnore: InsertFromSelect<TModel, TFilterServices>;
+	readonly insertManyOrIgnore: InsertMany<TModel, TFilterServices>;
+	readonly insertOrIgnore: (
+		input: TModel["insert"]["Type"],
+	) => Effect.Effect<
+		Option.Option<TModel["Type"]>,
+		SqlError | Schema.SchemaError,
+		TModel["insert"]["EncodingServices"] | TModel["DecodingServices"] | TFilterServices
+	>;
+	readonly upsert: ConditionalUpsert<
+		TModel,
+		UpdateOptions<TModel, TExcluded>,
+		TModel["insert"]["EncodingServices"] | TModel["DecodingServices"] | TFilterServices
+	>;
+	readonly upsertMany: ConditionalUpsertMany<
+		TModel,
+		UpdateOptions<TModel, TExcluded>,
+		TModel["insert"]["EncodingServices"] | TModel["DecodingServices"] | TFilterServices
+	>;
+}
+
+export function makeConflictWrites(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: {
+		readonly changes: RepositoryChanges;
+		readonly tableName: string;
+		readonly spanPrefix: string;
+		readonly conflictColumns: readonly string[];
+		readonly conflictWhere?: Readonly<Record<string, unknown>>;
+		readonly idColumns: readonly string[];
+	},
+) {
+	const { tableName, spanPrefix } = options;
+	const encode = Schema.encodeEffect(model.insert);
+	const decode = Schema.decodeUnknownEffect(model);
+	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+	const conditional = makeConditionalUpsert(model, sql, options);
+	const clause = makeConflictClause(model, sql, options);
+	function statement(input: unknown, updateColumns?: readonly string[]) {
+		return Effect.gen(function* () {
+			const encoded = yield* record(yield* encode(input));
+			const suffix = yield* clause(encoded, updateColumns);
+			return sql`insert into ${sql(tableName)} ${sql.insert(encoded)} ${suffix} returning *`;
+		});
+	}
+	return {
+		insertFromSelectOrIgnore: makeInsertFromSelect(model, sql, options, "insertFromSelectOrIgnore", (columns) =>
+			clause(Object.fromEntries(columns.map((key) => [key, undefined]))),
+		),
+		insertManyOrIgnore: makeInsertMany(model, sql, options, "insertManyOrIgnore", (row) => clause(row)),
+		insertOrIgnore: (input: unknown) =>
+			Effect.gen(function* () {
+				const rows = yield* yield* statement(input);
+				yield* options.changes.record(rows);
+				return rows.length === 0 ? Option.none() : Option.some(yield* decode(rows[0]));
+			}).pipe(options.changes.write, Effect.withSpan(`${spanPrefix}.insertOrIgnore`)),
+		upsert: (input: unknown, settings: { readonly updateColumns: readonly string[]; readonly updateWhere?: Readonly<Record<string, unknown>> }) =>
+			settings.updateWhere === undefined
+				? Effect.gen(function* () {
+						const rows = yield* yield* statement(input, settings.updateColumns);
+						yield* options.changes.record(rows);
+						return yield* decode(rows[0]);
+					}).pipe(options.changes.write, Effect.withSpan(`${spanPrefix}.upsert`))
+				: conditional([input], { ...settings, updateWhere: settings.updateWhere }).pipe(Effect.map((results) => results[0])),
+		upsertMany: (
+			inputs: readonly unknown[],
+			settings: { readonly updateColumns: readonly string[]; readonly updateWhere?: Readonly<Record<string, unknown>> },
+		) =>
+			settings.updateWhere === undefined
+				? makeInsertMany(model, sql, options, "upsertMany", (row) => clause(row, settings.updateColumns))(inputs)
+				: conditional(inputs, { ...settings, updateWhere: settings.updateWhere }),
+	};
+}

package/src/coordinateWorkerRelease.ts

@@ -0,0 +1,33 @@
+import { Duration, Effect } from "effect";
+import { readPostgresRelease } from "./postgresRelease.ts";
+import { releaseWorkers } from "./releaseWorkers.ts";
+import { makeWorkerRelease } from "./WorkerRelease.ts";
+
+export const coordinateWorkerRelease = Effect.fn("EffectSql.coordinateWorkerRelease")(function* (
+	release: string,
+	pollInterval: Duration.Input = "1 second",
+	table = "effect_sql_migrations",
+) {
+	const gate = yield* makeWorkerRelease();
+	const rows = yield* releaseWorkers(release, Duration.toMillis(pollInterval) * 5, table);
+	let claimed = false;
+	const poll = Effect.gen(function* () {
+		const owner = yield* readPostgresRelease(table);
+		if (owner?.release !== release) {
+			yield* gate.setActive(false).pipe(Effect.orDie);
+			yield* rows.remove;
+			claimed = false;
+		} else if (!claimed) {
+			claimed = yield* rows.claim;
+			if (claimed) {
+				yield* gate.setActive(true).pipe(Effect.orDie);
+			}
+		}
+	});
+	yield* Effect.addFinalizer(() => rows.remove.pipe(Effect.orDie));
+	// Heartbeats continue while offWork waits for active jobs to finish.
+	yield* Effect.forever(Effect.sleep(pollInterval).pipe(Effect.andThen(rows.heartbeat))).pipe(Effect.orDie, Effect.forkScoped);
+	yield* poll;
+	yield* Effect.forever(Effect.sleep(pollInterval).pipe(Effect.andThen(poll))).pipe(Effect.orDie, Effect.forkScoped);
+	return gate.service;
+});

package/src/insertFromSelect.ts

@@ -0,0 +1,47 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import type { Fragment } from "effect/sql/Statement";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
+import type { RepositorySelect } from "#repositoryQueries.ts";
+
+type CompatibleColumn<TType, TEncoded, TFields extends Schema.Struct.Fields> = {
+	[TKey in keyof TFields]: TFields[TKey]["Type"] extends TType ? (TFields[TKey]["Encoded"] extends TEncoded ? TKey : never) : never;
+}[keyof TFields] &
+	string;
+
+type ColumnMapping<TInput, TEncoded, TFields extends Schema.Struct.Fields> = {
+	[TKey in keyof TInput]: CompatibleColumn<TInput[TKey], TEncoded[Extract<TKey, keyof TEncoded>], TFields>;
+};
+
+export type InsertFromSelect<TModel extends Model.Any, TServices = never> = <TFields extends Schema.Struct.Fields, TSourceServices>(
+	source: RepositorySelect<TFields, TSourceServices>,
+	columns: ColumnMapping<TModel["insert"]["Type"], TModel["insert"]["Encoded"], TFields>,
+) => Effect.Effect<TModel["Type"][], SqlError | Schema.SchemaError, TSourceServices | TModel["DecodingServices"] | TServices>;
+
+export interface SelectWrites<TModel extends Model.Any> {
+	readonly insertFromSelect: InsertFromSelect<TModel>;
+}
+
+export function makeInsertFromSelect<TServices = never>(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: { readonly tableName: string; readonly spanPrefix: string; readonly changes: RepositoryChanges },
+	operation: string,
+	prepare: (columns: readonly string[]) => Effect.Effect<Fragment, Schema.SchemaError, TServices> = () => Effect.succeed(sql``),
+) {
+	const decode = Schema.decodeUnknownEffect(Schema.Array(model));
+	return (source: RepositorySelect<Schema.Struct.Fields, unknown>, columns: Readonly<Record<string, string>>) =>
+		Effect.gen(function* () {
+			const names = Object.keys(columns);
+			const selected = sql.csv(Object.values(columns).map((column) => sql`${sql(column)}`));
+			const target = sql.csv(names.map((column) => sql`${sql(column)}`));
+			const suffix = yield* prepare(names);
+			const statement = yield* source.statement;
+			const rows =
+				yield* sql`insert into ${sql(options.tableName)} (${target}) select ${selected} from (${statement}) as ${sql("source")} where true ${suffix} returning *`;
+			yield* options.changes.record(rows);
+			return yield* decode(rows);
+		}).pipe(options.changes.write, Effect.withSpan(`${options.spanPrefix}.${operation}`));
+}

package/src/latestPerGroup.ts

@@ -0,0 +1,58 @@
+import { Effect, Schema } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import type { Fragment } from "effect/sql/Statement";
+import { pinnedGroups } from "#pinnedGroups.ts";
+import type { LatestPerGroup } from "#repository.ts";
+import { makeFilter } from "#repositoryFilter.ts";
+
+export function latestPerGroup(model: Model.Any, sql: SqlClient.SqlClient, tableName: string) {
+	const { fieldAt, where } = makeFilter(model, sql);
+	return Effect.fnUntraced(function* (query: LatestPerGroup<Model.Any>, order: Fragment, rowLimit: number) {
+		yield* Effect.forEach(query.partitionBy, fieldAt);
+		const predicate = yield* where(query.where, true);
+		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);
+		if (pinned !== undefined && pinned.groups.length === 0) {
+			return [];
+		}
+		if (pinned !== undefined && sql.onDialectOrElse({ orElse: () => false, pg: () => true })) {
+			const remaining = yield* where(pinned.remaining, true);
+			const masks = new Map<string, (readonly unknown[])[]>();
+			for (const group of pinned.groups) {
+				const mask = group.map((value) => (value === null ? "0" : "1")).join("");
+				const groups = masks.get(mask) ?? [];
+				groups.push(group);
+				masks.set(mask, groups);
+			}
+			const branches = Array.from(masks.values(), (groups) => {
+				const values = sql.join(" union ", false)(groups.map((group) => sql`select ${sql.csv(group.map((value) => sql`${value}`))}`));
+				const matches = query.partitionBy.map((key, index) =>
+					groups[0]?.[index] === null ? sql`${sql(key)} is null` : sql`${sql(key)} = ${sql("__effect_sql_groups")}.${sql(key)}`,
+				);
+				// The empty table projection gives encoded parameters their actual PostgreSQL column types.
+				return sql`select ${sql("__effect_sql_latest")}.* from (
+					select ${partitions} from ${sql(tableName)} where false union ${values}
+				) as ${sql("__effect_sql_groups")} cross join lateral (
+					select ${columns} from ${sql(tableName)} where ${sql.and([...matches, remaining])} ${order} limit ${rowLimit}
+				) as ${sql("__effect_sql_latest")}`;
+			});
+			const ordering = sql.csv(query.orderBy.map(({ field, direction }) => sql`${sql(field)} ${sql.literal(direction === "desc" ? "desc" : "asc")}`));
+			const rows =
+				yield* sql`select ${columns} from (${sql.join(" union all ")(branches)}) as ${sql("__effect_sql_pinned")} order by ${partitions}, ${ordering}`;
+			return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(model.fields)))(rows);
+		}
+		let rankColumn = "__effect_sql_rank";
+		while (Object.hasOwn(model.fields, rankColumn)) {
+			rankColumn += "_";
+		}
+		const rows = yield* sql`select ${columns} from (
+			select ${columns}, row_number() over (partition by ${partitions} ${order}) as ${sql(rankColumn)}
+			from ${sql(tableName)} where ${predicate}
+		) as ${sql("__effect_sql_ranked")} where ${sql(rankColumn)} <= ${rowLimit}
+		order by ${partitions}, ${sql(rankColumn)}`;
+		return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(model.fields)))(rows);
+	});
+}

package/src/listenForChanges.ts

@@ -0,0 +1,97 @@
+import { Clock, Deferred, type Duration, Effect, type Exit, Queue, Scope } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { decodeKeys } from "./notifyPayload.ts";
+import type { PostgresChangesOptions } from "./postgresChanges.ts";
+
+function closeListener(scope: Scope.Closeable, outcome: Exit.Exit<unknown, unknown>, timeout: Duration.Input) {
+	return Effect.suspend(() => {
+		function bounded(finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) {
+			return (exit: Exit.Exit<unknown, unknown>) => finalizer(exit).pipe(Effect.interruptible, Effect.timeoutOption(timeout), Effect.asVoid);
+		}
+		// Bound each finalizer so a stalled UNLISTEN cannot prevent the native connection release that follows it.
+		if (scope.state._tag === "Open") {
+			const state = scope.state;
+			if (state.finalizer !== undefined) {
+				state.finalizer = bounded(state.finalizer);
+			}
+			if (state.finalizers !== undefined) {
+				for (const [key, finalizer] of state.finalizers) {
+					state.finalizers.set(key, bounded(finalizer));
+				}
+			}
+		}
+		return Scope.closeUnsafe(scope, outcome) ?? Effect.void;
+	});
+}
+
+export const listenForChanges = Effect.fn("PostgresChanges.listenForChanges")(function* (options: PostgresChangesOptions) {
+	const ready = yield* Deferred.make<void>();
+	const reactivity = yield* Reactivity.Reactivity;
+	const { client, channel, resync } = options;
+	const timeout = options.heartbeatTimeout ?? "10 seconds";
+	let lostAt: number | undefined;
+	const attempt = Effect.scoped(
+		Effect.gen(function* () {
+			const scope = yield* Effect.acquireRelease(Scope.make(), (listenerScope, exit) => closeListener(listenerScope, exit, timeout));
+			const token = JSON.stringify({ heartbeat: crypto.randomUUID() });
+			let ack = yield* Deferred.make<void>();
+			function receive(payload: string) {
+				if (payload === token) {
+					return Effect.asVoid(Deferred.succeed(ack, undefined));
+				}
+				if (!payload.startsWith("[")) {
+					return Effect.void;
+				}
+				return decodeKeys(payload).pipe(
+					Effect.flatMap((keys) => Effect.sync(() => reactivity.invalidateUnsafe(keys))),
+					Effect.catchCause(() => resync),
+				);
+			}
+			const listening = Effect.gen(function* () {
+				const notifications = yield* client.listen(channel).pipe(Scope.provide(scope));
+				yield* Effect.forever(
+					Effect.flatMap(Queue.takeAll(notifications), (batch) =>
+						Effect.forEach(batch, (notification) => receive(notification.payload), { discard: true }),
+					),
+				);
+			});
+			const send = Effect.asVoid(client`select pg_notify(${channel}, ${token})`);
+			const monitor = Effect.gen(function* () {
+				yield* Effect.raceFirst(Deferred.await(ack), Effect.forever(Effect.andThen(send, Effect.sleep("50 millis")))).pipe(Effect.timeout(timeout));
+				const streamCount = yield* resync;
+				if (lostAt !== undefined) {
+					const downtimeMs = (yield* Clock.currentTimeMillis) - lostAt;
+					yield* Effect.logInfo("PostgreSQL change listener recovered; resynchronized live streams").pipe(
+						Effect.annotateLogs({ downtimeMs, streamCount }),
+					);
+					lostAt = undefined;
+				}
+				yield* Deferred.succeed(ready, undefined);
+				yield* Effect.forever(
+					Effect.gen(function* () {
+						yield* Effect.sleep(options.heartbeatInterval ?? "5 seconds");
+						ack = yield* Deferred.make<void>();
+						yield* Effect.andThen(send, Deferred.await(ack)).pipe(Effect.timeout(timeout));
+					}),
+				);
+			});
+			yield* Effect.raceFirst(listening, monitor).pipe(Effect.onExit(() => resync));
+		}),
+	);
+	yield* Effect.forever(
+		attempt.pipe(
+			Effect.catchCause(() =>
+				Effect.gen(function* () {
+					if (lostAt !== undefined) {
+						yield* Effect.logDebug("PostgreSQL change listener reconnect failed; retrying");
+						return;
+					}
+					lostAt = yield* Clock.currentTimeMillis;
+					yield* Effect.logWarning("PostgreSQL change listener lost; resynchronizing live streams");
+				}),
+			),
+			Effect.andThen(Effect.sleep(options.retryDelay ?? "1 second")),
+		),
+	).pipe(Effect.forkScoped);
+	yield* Deferred.await(ready);
+});

package/src/makeAggregate.ts

@@ -0,0 +1,64 @@
+import { Effect, Schema, SchemaIssue } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import type { Fragment } from "effect/sql/Statement";
+import { aggregateColumn } from "#aggregateColumn.ts";
+import type { Aggregate } from "#aggregateQuery.ts";
+import { makeQueryClauses } from "#makeQueryClauses.ts";
+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>;
+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))));
+				}
+				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`));
+}

package/src/makeConflictClause.ts

@@ -0,0 +1,53 @@
+import { Effect, Schema, SchemaAST, SchemaIssue } from "effect";
+import type { Model } from "effect/schema";
+import type { SqlClient } from "effect/sql";
+import { makeFilter } from "#repositoryFilter.ts";
+
+export function makeConflictClause(
+	model: Model.Any,
+	sql: SqlClient.SqlClient,
+	options: {
+		readonly tableName: string;
+		readonly conflictColumns: readonly string[];
+		readonly conflictWhere?: Readonly<Record<string, unknown>>;
+		readonly idColumns: readonly string[];
+	},
+) {
+	const { conflictColumns, idColumns } = options;
+	const updateFilter = makeFilter(model, sql, options);
+	const filter = makeFilter(model, sql);
+	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) {
+		return Effect.fail(new Schema.SchemaError(new SchemaIssue.Pointer([column], new SchemaIssue.UnexpectedKey(model.ast, column))));
+	}
+	function validateColumns(encoded: Readonly<Record<string, unknown>>, columns: readonly string[], excluded: readonly string[] = []) {
+		return Effect.gen(function* () {
+			if (columns.length === 0) {
+				return yield* invalid("");
+			}
+			for (const column of columns) {
+				if (!(Object.hasOwn(model.fields, column) && Object.hasOwn(encoded, column)) || excluded.includes(column)) {
+					return yield* invalid(column);
+				}
+			}
+		});
+	}
+	function clause(encoded: Readonly<Record<string, unknown>>, updateColumns?: readonly string[], updateWhere?: Readonly<Record<string, unknown>>) {
+		return Effect.gen(function* () {
+			yield* validateColumns(encoded, conflictColumns);
+			if (updateColumns !== undefined) {
+				yield* validateColumns(encoded, updateColumns, [...idColumns, ...conflictColumns, ...immutable]);
+			}
+			const conflict = sql.csv(conflictColumns.map((column) => sql`${sql(column)}`));
+			const where = options.conflictWhere === undefined ? sql`` : sql`where ${yield* filter.where(options.conflictWhere)}`;
+			const action =
+				updateColumns === undefined
+					? sql`do nothing`
+					: sql`do update set ${sql.csv(updateColumns.map((column) => sql`${sql(column)} = excluded.${sql(column)}`))}`;
+			const condition = updateWhere === undefined ? sql`` : sql`where ${yield* updateFilter.where(updateWhere, true, true)}`;
+			return sql`on conflict (${conflict}) ${where} ${action} ${condition}`;
+		});
+	}
+	return clause;
+}