@shivaedev/sql 0.33.0 → 0.35.0

package/src/batchWrites.ts

@@ -1,10 +1,10 @@
 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 { RepositoryChanges } from "./repositoryChanges.ts";
-import { makeUpsertDecoder, upsertReturning } from "./upsertResult.ts";
+import type { RepositoryChanges } from "#repositoryChanges.ts";
+import { makeUpsertDecoder, upsertReturning } from "#upsertResult.ts";
 
 export type InsertMany<TModel extends Model.Any, TServices = never> = (
 	inputs: readonly TModel["insert"]["Type"][],
@@ -14,19 +14,20 @@ export interface BatchWrites<TModel extends Model.Any> {
 	readonly insertMany: InsertMany<TModel>;
 }
 
-export function makeInsertMany<TServices = never>(
+export const makeInsertMany = Effect.fnUntraced(function* <TServices = never>(
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: { readonly tableName: string; readonly spanPrefix: string; readonly changes: RepositoryChanges },
 	operation: string,
-	prepare: (row: Readonly<Record<string, unknown>>) => Effect.Effect<Fragment, Schema.SchemaError, TServices> = () => Effect.succeed(sql``),
+	prepare?: (row: Readonly<Record<string, unknown>>) => Effect.Effect<Fragment, SqlError | Schema.SchemaError, TServices>,
 	upsert = false,
 ) {
+	const sql = yield* SqlClient.SqlClient;
+	const prepareRow = prepare ?? (() => Effect.succeed(sql``));
 	const encode = Schema.encodeEffect(model.insert);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const decode = Schema.decodeUnknownEffect(Schema.Array(model));
 	const decodeUpsert = makeUpsertDecoder(model);
-	const returning = options.changes.returning(upsert ? upsertReturning(sql) : sql`*`);
+	const returning = options.changes.returning(upsert ? yield* upsertReturning() : sql`*`);
 	return (inputs: readonly unknown[]) =>
 		Effect.gen(function* () {
 			if (inputs.length === 0) {
@@ -56,7 +57,7 @@ export function makeInsertMany<TServices = never>(
 			for (const row of rows) {
 				const value = sql`(${sql.csv(columns.map((column) => (Object.hasOwn(row, column) ? sql`${row[column]}` : sql`default`)))})`;
 				const size = value.compile()[1].length;
-				const prepared = yield* prepare(row);
+				const prepared = yield* prepareRow(row);
 				const suffixSize = sql`${prepared}`.compile()[1].length;
 				// Bound native fragment size as well as PostgreSQL's 65,535 bind parameters.
 				if (chunk.length > 0 && (chunk.length === chunkSize || parameters + size + suffixSize > 10_000)) {
@@ -70,4 +71,4 @@ export function makeInsertMany<TServices = never>(
 			yield* options.changes.record(changedRows);
 			return results;
 		}).pipe(options.changes.write, Effect.withSpan(`${options.spanPrefix}.${operation}`));
-}
+});

package/src/batchedDelete.ts

@@ -7,42 +7,69 @@ import type { RepositoryChanges } from "#repositoryChanges.ts";
 import { type FindManyFilter, makeFilter } from "#repositoryFilter.ts";
 import { tryPurgeLock } from "#tryPurgeLock.ts";
 
-export interface BatchedDeleteOptions<TModel extends Model.Any> {
+export interface PurgeLimits {
 	readonly batchSize: number;
 	readonly maxRows: number;
 	readonly pause: Duration.Input;
-	readonly where: FindManyFilter<TModel>;
 }
 
 export class BatchedDeleteUnavailable extends Data.TaggedError("BatchedDeleteUnavailable")<{
 	readonly reason: "transaction" | "dialect";
 }> {}
 
+export const PositiveRowCount = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+const Nonnegative = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+const Limits = Schema.Struct({ batchSize: PositiveRowCount, maxRows: Nonnegative });
+
+export const runPurgeBatches = Effect.fnUntraced(function* <E, R>(
+	tableName: string,
+	options: PurgeLimits,
+	batch: (limit: number) => Effect.Effect<{ readonly count: number; readonly done: boolean }, E, R>,
+	prepare?: Effect.Effect<unknown, E, R>,
+) {
+	const sql = yield* SqlClient.SqlClient;
+	if (sql.driver !== "pg") {
+		return yield* new BatchedDeleteUnavailable({ reason: "dialect" });
+	}
+	if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {
+		return yield* new BatchedDeleteUnavailable({ reason: "transaction" });
+	}
+	const { batchSize, maxRows } = yield* Schema.decodeUnknownEffect(Limits)(options);
+	if (prepare !== undefined) {
+		yield* prepare;
+	}
+	if (maxRows === 0 || !(yield* tryPurgeLock(tableName))) {
+		return 0;
+	}
+	let removed = 0;
+	while (removed < maxRows) {
+		const { count, done } = yield* batch(Math.min(batchSize, maxRows - removed));
+		removed += count;
+		if (done || count === 0 || removed === maxRows) {
+			break;
+		}
+		yield* Effect.sleep(options.pause);
+	}
+	return removed;
+});
+
+export interface BatchedDeleteOptions<TModel extends Model.Any> extends PurgeLimits {
+	readonly where: FindManyFilter<TModel>;
+}
+
 export interface BatchedDelete<TModel extends Model.Any> {
 	readonly deleteBatched: (
 		options: BatchedDeleteOptions<TModel>,
 	) => Effect.Effect<number, SqlError | Schema.SchemaError | BatchedDeleteUnavailable, TModel["fields"][keyof TModel["fields"]]["EncodingServices"]>;
 }
 
-const Positive = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
-const Nonnegative = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
-const Limits = Schema.Struct({ batchSize: Positive, maxRows: Nonnegative });
-
 export const makeBatchedDelete = Effect.fnUntraced(function* (
 	model: Model.Any,
 	{ tableName, spanPrefix }: { readonly tableName: string; readonly spanPrefix: string },
 	changes: RepositoryChanges,
 ) {
 	const sql = yield* SqlClient.SqlClient;
-	const { where } = makeFilter(model, sql);
-	const available = Effect.gen(function* () {
-		if (sql.driver !== "pg") {
-			return yield* new BatchedDeleteUnavailable({ reason: "dialect" });
-		}
-		if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {
-			return yield* new BatchedDeleteUnavailable({ reason: "transaction" });
-		}
-	});
+	const { where } = yield* makeFilter(model);
 	function deleteBatch(predicate: Fragment, limit: number) {
 		const count = SqlSchema.findOne({
 			execute: (batchLimit) => sql`with removed as (
@@ -62,32 +89,18 @@ export const makeBatchedDelete = Effect.fnUntraced(function* (
 		);
 	}
 
-	const runBatches = Effect.fnUntraced(function* (options: BatchedDeleteOptions<Model.Any>, predicate: Fragment) {
-		const { batchSize, maxRows } = options;
-		let removed = 0;
-		while (removed < maxRows) {
-			const limit = Math.min(batchSize, maxRows - removed);
-			const count = yield* deleteBatch(predicate, limit);
-			removed += count;
-			if (count < limit || removed === maxRows) {
-				break;
-			}
-			yield* Effect.sleep(options.pause);
-		}
-		return removed;
-	});
-
 	return (options: BatchedDeleteOptions<Model.Any>) =>
 		Effect.gen(function* () {
-			yield* available;
-			const { maxRows } = yield* Schema.decodeUnknownEffect(Limits)(options);
-			const predicate = yield* where(options.where, true, true);
-			if (maxRows === 0) {
-				return 0;
-			}
-			if (!(yield* tryPurgeLock(tableName).pipe(Effect.provideService(SqlClient.SqlClient, sql)))) {
-				return 0;
-			}
-			return yield* runBatches(options, predicate);
-		}).pipe(Effect.scoped, Effect.withSpan(`${spanPrefix}.deleteBatched`));
+			const predicate = yield* Effect.cached(where(options.where, true, true));
+			return yield* runPurgeBatches(
+				tableName,
+				options,
+				(limit) =>
+					Effect.gen(function* () {
+						const count = yield* deleteBatch(yield* predicate, limit);
+						return { count, done: count < limit };
+					}),
+				predicate,
+			);
+		}).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.scoped, Effect.withSpan(`${spanPrefix}.deleteBatched`));
 });

package/src/changes.ts

@@ -0,0 +1,12 @@
+import { type BucketKey, type ItemKey, invalidationKeys } from "@shivaedev/changes/keys.ts";
+import { type AnnouncementOptions, invalidateOnCommit } from "#transact.ts";
+
+export interface ChangeDeclaration {
+	readonly covers: Readonly<Record<string, readonly (ItemKey | BucketKey)[]>>;
+	readonly record: (options?: AnnouncementOptions) => ReturnType<typeof invalidateOnCommit>;
+}
+
+export function changes(covers: ChangeDeclaration["covers"]): ChangeDeclaration {
+	const keys = invalidationKeys(Object.values(covers).flat());
+	return { covers, record: (options) => invalidateOnCommit(keys, options) };
+}

package/src/compositeRepository.ts

@@ -1,7 +1,7 @@
 import type { Cause } from "effect";
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
-import { type SqlClient, SqlSchema } from "effect/sql";
+import { SqlClient, SqlSchema } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import type { BatchedDelete } from "#batchedDelete.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
@@ -41,9 +41,8 @@ export type Repository<TModel extends Model.Any, TId extends PrimaryKey<TModel>>
 				}
 			: never);
 
-export function makeCompositeCrud(
+export const makeCompositeCrud = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: {
 		readonly columns: readonly string[];
 		readonly tableName: string;
@@ -51,19 +50,20 @@ export function makeCompositeCrud(
 	},
 	changes: RepositoryChanges,
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	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 entries: [string, Schema.Constraint][] = [];
+	for (const column of columns) {
+		const field = model.fields[column];
+		if (field === undefined) {
+			return yield* Effect.die(new Error(`Unknown ID column: ${column}`));
+		}
+		entries.push([column, field]);
+	}
+	const fields = Object.fromEntries(entries);
 	const Key = columns.length === 1 ? model.fields[columns[0] ?? ""] : Schema.Struct(fields);
 	if (Key === undefined) {
-		throw new Error("Unknown repository ID column");
+		return yield* Effect.die(new Error("Unknown repository ID column"));
 	}
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	function predicate(input: Readonly<Record<string, unknown>>) {
@@ -80,7 +80,7 @@ export function makeCompositeCrud(
 	});
 
 	return {
-		...repositoryWrites(model, sql, { ...options, idColumns: columns }, changes),
+		...(yield* repositoryWrites(model, { ...options, idColumns: columns }, changes)),
 		findById: (id: unknown) => find(id).pipe(Effect.withSpan(`${spanPrefix}.findById`)),
 	};
-}
+});

package/src/conditionalUpsert.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 { makeConflictClause } from "#makeConflictClause.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
@@ -53,9 +53,8 @@ export interface ConditionalUpsertMany<TModel extends Model.Any, TOptions, TServ
 	): Effect.Effect<UpsertRow<TModel["Type"]>[], SqlError | Schema.SchemaError, TServices>;
 }
 
-export function makeConditionalUpsert(
+export const makeConditionalUpsert = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: {
 		readonly tableName: string;
 		readonly spanPrefix: string;
@@ -65,10 +64,12 @@ export function makeConditionalUpsert(
 		readonly idColumns: readonly string[];
 	},
 ) {
+	const sql = yield* SqlClient.SqlClient;
+	const returning = yield* upsertReturning();
 	const encode = Schema.encodeEffect(model.insert);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const decode = makeUpsertDecoder(model);
-	const clause = makeConflictClause(model, sql, options);
+	const clause = yield* makeConflictClause(model, options);
 	return (
 		inputs: readonly unknown[],
 		settings: { readonly updateColumns: readonly UpsertAssignment[]; readonly updateWhere: Readonly<Record<string, unknown>> },
@@ -78,7 +79,7 @@ export function makeConditionalUpsert(
 				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 ${options.changes.returning(upsertReturning(sql))}`;
+					return sql`insert into ${sql(options.tableName)} ${sql.insert(row)} ${suffix} returning ${options.changes.returning(returning)}`;
 				}),
 			);
 			const changedRows: Readonly<Record<string, unknown>>[] = [];
@@ -99,4 +100,4 @@ export function makeConditionalUpsert(
 			yield* options.changes.record(changedRows);
 			return results;
 		}).pipe(options.changes.write, Effect.withSpan(`${options.spanPrefix}.conditionalUpsert`));
-}
+});

package/src/conflictWrites.ts

@@ -1,6 +1,6 @@
 import { Effect, Option, 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 InsertMany, makeInsertMany } from "#batchWrites.ts";
 import { type ConditionalUpsert, type ConditionalUpsertMany, makeConditionalUpsert } from "#conditionalUpsert.ts";
@@ -40,9 +40,8 @@ export interface ConflictWrites<TModel extends Model.Any, TExcluded extends Prop
 	>;
 }
 
-export function makeConflictWrites(
+export const makeConflictWrites = Effect.fnUntraced(function* (
 	model: Model.Any,
-	sql: SqlClient.SqlClient,
 	options: {
 		readonly changes: RepositoryChanges;
 		readonly tableName: string;
@@ -52,25 +51,27 @@ export function makeConflictWrites(
 		readonly idColumns: readonly string[];
 	},
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	const { tableName, spanPrefix } = options;
+	const returning = yield* upsertReturning();
 	const encode = Schema.encodeEffect(model.insert);
 	const decode = Schema.decodeUnknownEffect(model);
 	const decodeUpsert = makeUpsertDecoder(model);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
-	const conditional = makeConditionalUpsert(model, sql, options);
-	const clause = makeConflictClause(model, sql, options);
+	const conditional = yield* makeConditionalUpsert(model, options);
+	const clause = yield* makeConflictClause(model, options);
 	function statement(input: unknown, updateColumns?: readonly UpsertAssignment[]) {
 		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 ${options.changes.returning(updateColumns === undefined ? sql`*` : upsertReturning(sql))}`;
+			return sql`insert into ${sql(tableName)} ${sql.insert(encoded)} ${suffix} returning ${options.changes.returning(updateColumns === undefined ? sql`*` : returning)}`;
 		});
 	}
 	return {
-		insertFromSelectOrIgnore: makeInsertFromSelect(model, sql, options, "insertFromSelectOrIgnore", (columns) =>
+		insertFromSelectOrIgnore: yield* makeInsertFromSelect(model, options, "insertFromSelectOrIgnore", (columns) =>
 			clause(Object.fromEntries(columns.map((key) => [key, undefined]))),
 		),
-		insertManyOrIgnore: makeInsertMany(model, sql, options, "insertManyOrIgnore", (row) => clause(row)),
+		insertManyOrIgnore: yield* makeInsertMany(model, options, "insertManyOrIgnore", (row) => clause(row)),
 		insertOrIgnore: (input: unknown) =>
 			Effect.gen(function* () {
 				const rows = yield* yield* statement(input);
@@ -93,7 +94,10 @@ export function makeConflictWrites(
 			settings: { readonly updateColumns: readonly UpsertAssignment[]; readonly updateWhere?: Readonly<Record<string, unknown>> },
 		) =>
 			settings.updateWhere === undefined
-				? makeInsertMany(model, sql, options, "upsertMany", (row) => clause(row, settings.updateColumns), true)(inputs)
+				? Effect.flatMap(
+						makeInsertMany(model, options, "upsertMany", (row) => clause(row, settings.updateColumns), true),
+						(insertMany) => insertMany(inputs),
+					).pipe(Effect.provideService(SqlClient.SqlClient, sql))
 				: conditional(inputs, { ...settings, updateWhere: settings.updateWhere }),
 	};
-}
+});

package/src/deleteGroupsBatched.ts

@@ -0,0 +1,41 @@
+import { Effect, Schema } from "effect";
+import { PositiveRowCount, type PurgeLimits, runPurgeBatches } from "#batchedDelete.ts";
+import { transact } from "#transact.ts";
+
+export interface DeleteGroup<T> {
+	readonly rowCount: number;
+	readonly value: T;
+}
+
+export interface DeleteGroupsBatchedOptions<T, TSelectError, TSelectServices, TDeleteError, TDeleteServices> extends PurgeLimits {
+	readonly delete: (group: T) => Effect.Effect<unknown, TDeleteError, TDeleteServices>;
+	readonly select: (limit: number) => Effect.Effect<readonly DeleteGroup<T>[], TSelectError, TSelectServices>;
+	readonly tableName: string;
+}
+
+export const deleteGroupsBatched = Effect.fn("Sql.deleteGroupsBatched")(function* <T, TSelectError, TSelectServices, TDeleteError, TDeleteServices>(
+	options: DeleteGroupsBatchedOptions<T, TSelectError, TSelectServices, TDeleteError, TDeleteServices>,
+) {
+	return yield* runPurgeBatches(options.tableName, options, (limit) =>
+		transact(
+			Effect.gen(function* () {
+				const candidates = yield* options.select(limit);
+				const selected: T[] = [];
+				let count = 0;
+				for (const candidate of candidates) {
+					const size = yield* Schema.decodeUnknownEffect(PositiveRowCount)(candidate.rowCount);
+					if (size > limit - count) {
+						break;
+					}
+					selected.push(candidate.value);
+					count += size;
+				}
+				for (const group of selected) {
+					yield* options.delete(group);
+				}
+				return { count, done: candidates.length === 0 };
+			}),
+			{ onSqlError: (error) => error },
+		),
+	).pipe(Effect.scoped);
+});

package/src/insertFromSelect.ts

@@ -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 { RepositoryChanges } from "#repositoryChanges.ts";
@@ -24,24 +24,24 @@ export interface SelectWrites<TModel extends Model.Any> {
 	readonly insertFromSelect: InsertFromSelect<TModel>;
 }
 
-export function makeInsertFromSelect<TServices = never>(
+export const makeInsertFromSelect = Effect.fnUntraced(function* <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``),
+	prepare?: (columns: readonly string[]) => Effect.Effect<Fragment, SqlError | Schema.SchemaError, TServices>,
 ) {
+	const sql = yield* SqlClient.SqlClient;
 	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 suffix = yield* prepare?.(names) ?? Effect.succeed(sql``);
 			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 ${options.changes.returning()}`;
 			yield* options.changes.record(rows);
 			return yield* decode(rows);
 		}).pipe(options.changes.write, Effect.withSpan(`${options.spanPrefix}.${operation}`));
-}
+});

package/src/invalidationKeys.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+import { invalidationKeys, Key, recordKey } from "@shivaedev/changes/keys.ts";
+import type { InvalidationKeys } from "#transact.ts";
+
+export interface Invalidation {
+	readonly key: unknown;
+	readonly publication: "local" | "shared";
+}
+
+const isKey = Schema.is(Key);
+
+function isList(keys: InvalidationKeys): keys is readonly unknown[] {
+	return Array.isArray(keys);
+}
+
+export function flatten(keys: InvalidationKeys): readonly unknown[] {
+	return isList(keys)
+		? keys.flatMap<unknown>((key) => (isKey(key) ? invalidationKeys([key]) : [key]))
+		: Object.entries(keys).flatMap(([name, ids]) => [name, ...ids.map((id) => recordKey(name, id))]);
+}
+
+export function keysOf(changes: readonly Invalidation[]) {
+	return [...new Set(changes.map((change) => change.key))];
+}

package/src/keysetPage.ts

@@ -0,0 +1,54 @@
+import { Effect, Option, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import type { Fragment } from "effect/sql/Statement";
+
+export interface KeysetOrder<TCursor> {
+	readonly column: string | Fragment;
+	readonly direction: "asc" | "desc";
+	readonly value: (cursor: TCursor) => string | number | bigint | boolean;
+}
+
+export interface KeysetPageQuery {
+	readonly limit: number;
+	readonly orderBy: Fragment;
+	readonly seek: Fragment;
+}
+
+export interface KeysetPage<TRow, TCursor> {
+	readonly next: Option.Option<TCursor>;
+	readonly rows: readonly TRow[];
+}
+
+const PageSize = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0), Schema.isLessThan(Number.MAX_SAFE_INTEGER));
+
+export const keysetPage = Effect.fnUntraced(function* <TRow, TCursor, E, R>(options: {
+	readonly limit: number;
+	readonly after?: TCursor | undefined;
+	readonly orderBy: readonly KeysetOrder<TCursor>[];
+	readonly tieBreaker: KeysetOrder<TCursor>;
+	readonly cursorFor: (row: TRow) => TCursor;
+	readonly read: (query: KeysetPageQuery) => Effect.Effect<readonly TRow[], E, R>;
+}): Effect.fn.Return<KeysetPage<TRow, TCursor>, E | Schema.SchemaError, R | SqlClient.SqlClient> {
+	const limit = yield* Schema.decodeUnknownEffect(PageSize)(options.limit);
+	const sql = yield* SqlClient.SqlClient;
+	const order = [...options.orderBy, options.tieBreaker];
+	const columns = order.map(({ column }) => (typeof column === "string" ? sql`${sql(column)}` : column));
+	const after = options.after;
+	const values = after === undefined ? undefined : order.map(({ value }) => value(after));
+	const seek =
+		values === undefined
+			? sql`true`
+			: sql.or(
+					order.map(({ direction }, index) =>
+						sql.and([
+							...columns.slice(0, index).map((column, previous) => sql`${column} = ${values[previous]}`),
+							direction === "asc" ? sql`${columns[index]} > ${values[index]}` : sql`${columns[index]} < ${values[index]}`,
+						]),
+					),
+				);
+	const orderBy = sql.csv(order.map(({ direction }, index) => sql`${columns[index]} ${sql.literal(direction === "asc" ? "asc" : "desc")}`));
+	const found = yield* options.read({ limit: limit + 1, orderBy, seek });
+	const rows = found.slice(0, limit);
+	const last = rows.at(-1);
+	return { next: found.length > limit && last !== undefined ? Option.some(options.cursorFor(last)) : Option.none(), rows };
+});

package/src/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);
 	});
-}
+});