@shivaedev/sql 0.27.0 → 0.29.0

package/src/testing.ts

@@ -76,8 +76,12 @@ export class PublishedKeysMismatch extends Data.TaggedError("PublishedKeysMismat
 	}
 }
 
-export function expectPublished(keys: readonly unknown[]) {
-	return Effect.fn("Changes.expectPublished")(function* <A, E, R>(body: Effect.Effect<A, E, R>) {
+export function expectPublished(keys: readonly unknown[]): <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | PublishedKeysMismatch, R>;
+export function expectPublished<A>(
+	keys: (result: A) => readonly unknown[],
+): <E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | PublishedKeysMismatch, R>;
+export function expectPublished<A>(keys: readonly unknown[] | ((result: A) => readonly unknown[])) {
+	return Effect.fn("Changes.expectPublished")(function* <E, R>(body: Effect.Effect<A, E, R>) {
 		const observer = yield* ChangeObserver;
 		const actual = new Set<unknown>();
 		const result = yield* body.pipe(
@@ -90,7 +94,7 @@ export function expectPublished(keys: readonly unknown[]) {
 				return observer(event);
 			}),
 		);
-		const expected = new Set(keys);
+		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] }));
 		}

package/src/tupleIn.ts

@@ -1,6 +1,33 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
-import type { SqlClient } from "effect/sql";
+import { SqlClient } from "effect/sql";
+import { tupleUnnest } from "#tupleUnnest.ts";
+
+export type TupleColumnType =
+	| "bool"
+	| "bpchar"
+	| "bytea"
+	| "cidr"
+	| "date"
+	| "float4"
+	| "float8"
+	| "inet"
+	| "int2"
+	| "int4"
+	| "int8"
+	| "interval"
+	| "jsonb"
+	| "name"
+	| "numeric"
+	| "oid"
+	| "regclass"
+	| "text"
+	| "time"
+	| "timestamp"
+	| "timestamptz"
+	| "timetz"
+	| "uuid"
+	| "varchar";
 
 export const tupleFilter = Symbol("sql/tupleIn");
 type Row<TModel extends Model.Any> = Schema.Struct.Type<TModel["fields"]>;
@@ -11,6 +38,7 @@ export interface TupleFilter<TModel extends Model.Any> {
 		readonly model: TModel;
 		readonly fields: readonly Key<TModel>[];
 		readonly values: readonly (readonly unknown[])[];
+		readonly types: readonly TupleColumnType[];
 	};
 }
 
@@ -18,8 +46,9 @@ export function tupleIn<TModel extends Model.Any, const TFields extends readonly
 	model: TModel,
 	fields: TFields,
 	values: readonly { readonly [TIndex in keyof TFields]: Row<TModel>[TFields[TIndex]] }[],
+	types: Readonly<Record<TFields[number], TupleColumnType>>,
 ): TupleFilter<TModel> {
-	return { [tupleFilter]: { fields, model, values } };
+	return { [tupleFilter]: { fields, model, types: fields.map((field: TFields[number]) => types[field]), values } };
 }
 
 export function tuplePredicate(
@@ -35,10 +64,14 @@ export function tuplePredicate(
 		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)}`));
-		// Row comparisons retain column type inference for string-encoded numerics without PostgreSQL's deeply nested row-IN rewrite.
-		const rows = yield* Effect.forEach(tuple.values, (value) =>
-			Effect.map(encode(value), (encoded) => sql`(${columns}) = (${sql.csv(encoded.map((entry) => sql`${entry}`))})`),
-		);
-		return rows.length === 0 ? sql`1 = 0` : sql.or(rows);
+		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/tupleUnnest.ts

@@ -0,0 +1,25 @@
+import { Effect, Result } from "effect";
+import { SqlClient } from "effect/sql";
+import type { TupleColumnType } from "#tupleIn.ts";
+
+export const tupleUnnest = Effect.fnUntraced(function* (types: readonly TupleColumnType[], rows: readonly (readonly unknown[])[]) {
+	const sql = yield* SqlClient.SqlClient;
+	const pg = yield* Effect.promise(() => import("@effect/sql-pg/PgTypes"));
+	const arrays = types.map((type, index) => {
+		const entries = rows.map((row) => row[index]);
+		const values = entries.map((value) => (pg.isParameter(value) ? value.value : value));
+		// String-encoded fields rely on PostgreSQL input casts, including numerics and dates.
+		const first = entries.find((value) => value !== null && value !== undefined);
+		let oid: number = pg.OID[type];
+		if (pg.isParameter(first)) {
+			oid = first.oid;
+		} else if (first instanceof Date) {
+			oid = pg.OID.timestamptz;
+		} else if (values.every((value) => value === null || typeof value === "string")) {
+			oid = pg.OID.text;
+		}
+		const parameter = Result.getOrThrow(pg.array(values, oid));
+		return sql`${parameter}::${sql.literal(type)}[]`;
+	});
+	return sql`unnest(${sql.csv(arrays)})`;
+});