@shivaedev/sql 0.25.0 → 0.26.1

package/src/postgresChanges.ts

@@ -2,8 +2,9 @@ import { Context, type Duration, Effect, Layer, type Queue, type Scope } from "e
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
+import { CommandRecovery } from "#internal/CommandRecovery.ts";
 import { listenForChanges } from "./listenForChanges.ts";
-import { encodeKeys } from "./notifyPayload.ts";
+import { encodeKeys, resyncPayload } from "./notifyPayload.ts";
 import { BeforeCommit, CommittedSink } from "./transact.ts";
 
 export interface PostgresNotification {
@@ -17,8 +18,10 @@ export interface PostgresChangeClient extends SqlClient.SqlClient {
 export interface PostgresChangesOptions {
 	readonly channel: string;
 	readonly client: PostgresChangeClient;
+	readonly connectionSetting?: string;
 	readonly heartbeatInterval?: Duration.Input;
 	readonly heartbeatTimeout?: Duration.Input;
+	readonly listenerClient?: Pick<PostgresChangeClient, "listen">;
 	readonly resync: Effect.Effect<number>;
 	readonly retryDelay?: Duration.Input;
 }
@@ -42,7 +45,12 @@ export function postgresChanges(options: PostgresChangesOptions) {
 					sql.transactionService === options.client.transactionService ? Effect.void : Reactivity.invalidate(keys),
 				);
 			}
-			return Context.make(BeforeCommit, notify).pipe(Context.add(CommittedSink, committed));
+			const recover = options.resync.pipe(
+				Effect.andThen(options.client`select pg_notify(${options.channel}, ${resyncPayload})`),
+				Effect.catchCause((cause) => Effect.logError("Committed command Resync broadcast failed; other hosts may remain stale", cause)),
+				Effect.asVoid,
+			);
+			return Context.make(BeforeCommit, notify).pipe(Context.add(CommittedSink, committed), Context.add(CommandRecovery, recover));
 		}),
 	);
 }

package/src/postgresLayer.ts

@@ -0,0 +1,27 @@
+import * as PgClient from "@effect/sql-pg/PgClient";
+import * as PgPool from "@effect/sql-pg/PgPool";
+import { Context, Effect, Layer, type Redacted } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { SqlClient } from "effect/sql";
+import { makePostgresClient } from "#adapters/makePostgresClient.ts";
+import { postgresStream } from "#adapters/postgresStream.ts";
+import type { SqlNameTransforms } from "#clientOptions.ts";
+import { databaseAddress } from "#databaseAddress.ts";
+
+export interface PostgresOptions extends SqlNameTransforms {
+	readonly applicationName?: string | undefined;
+	readonly maxConnections?: number | undefined;
+}
+
+export function postgresLayer(url: Redacted.Redacted<string>, options?: PostgresOptions) {
+	return Layer.effectContext(
+		Effect.gen(function* () {
+			const address = databaseAddress(url);
+			const stream = yield* postgresStream(url, address);
+			const config = { ...options, ...address, stream, url };
+			const pool = yield* PgPool.make(config);
+			const client = yield* makePostgresClient(config).pipe(Effect.provideService(PgPool.PgPool, pool));
+			return Context.make(PgPool.PgPool, pool).pipe(Context.add(PgClient.PgClient, client), Context.add(SqlClient.SqlClient, client));
+		}),
+	).pipe(Layer.provide(Reactivity.layer));
+}

package/src/postgresRelease.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/sql";
 import type { SchemaComponent } from "./SchemaComponent.ts";
 
@@ -6,15 +6,19 @@ export const readPostgresRelease = Effect.fn("EffectSql.readPostgresRelease")(fu
 	const sql = yield* SqlClient.SqlClient;
 	const name = `${table}_release`;
 	const identifier = sql`${sql(name)}`.compile()[0];
-	const [exists] = yield* sql<{ name: string | null }>`select to_regclass(${identifier})::text as name`.withoutTransform;
+	const [exists] = yield* sql`select to_regclass(${identifier})::text as name`.withoutTransform.pipe(
+		Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ name: Schema.NullOr(Schema.String) })))),
+	);
 	if (exists === undefined || exists.name === null) {
 		return undefined;
 	}
-	const [row] = yield* sql<{ release: string; recordedAt: Date }>`select release, recorded_at as "recordedAt" from ${sql(name)}`.withoutTransform;
+	const [row] = yield* sql`select release, recorded_at as "recordedAt" from ${sql(name)}`.withoutTransform.pipe(
+		Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ recordedAt: Schema.Date, release: Schema.String })))),
+	);
 	return row;
 });
 
-export function postgresRelease(release: string, table = "effect_sql_migrations"): SchemaComponent {
+export function postgresRelease(release: string, table = "effect_sql_migrations") {
 	return {
 		apply: Effect.gen(function* () {
 			const sql = yield* SqlClient.SqlClient;
@@ -37,5 +41,5 @@ export function postgresRelease(release: string, table = "effect_sql_migrations"
 			const current = yield* readPostgresRelease(table);
 			return current?.release === release ? undefined : `Expected release ${release}; recorded ${current?.release ?? "none"}`;
 		}),
-	};
+	} satisfies SchemaComponent;
 }

package/src/releaseWorkers.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Random, Schema } from "effect";
 import { SqlClient } from "effect/sql";
 
 export const releaseWorkers = Effect.fn("EffectSql.releaseWorkers")(function* (
@@ -7,12 +7,14 @@ export const releaseWorkers = Effect.fn("EffectSql.releaseWorkers")(function* (
 	table = "effect_sql_migrations",
 ) {
 	const sql = yield* SqlClient.SqlClient;
-	const processId = crypto.randomUUID();
+	const processId = `${yield* Random.nextInt}:${yield* Random.nextInt}`;
 	const workers = `${table}_workers`;
 	return {
 		claim: sql.withTransaction(
 			Effect.gen(function* () {
-				const [owner] = yield* sql<{ release: string }>`select release from ${sql(`${table}_release`)} where id = true for update`.withoutTransform;
+				const [owner] = yield* sql`select release from ${sql(`${table}_release`)} where id = true for update`.withoutTransform.pipe(
+					Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ release: Schema.String })))),
+				);
 				if (owner?.release !== release) {
 					return false;
 				}

package/src/testing.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect";
+import { Data, Effect, Schema } from "effect";
 import { SqlClient } from "effect/sql";
 import { type BucketKey, type ItemKey, invalidationKeys } from "@shivaedev/changes/keys.ts";
 import { ChangeDeclarations } from "#ChangeDeclarations.ts";
@@ -10,12 +10,6 @@ export interface ChangeCoverage {
 	readonly covers: Readonly<Record<string, readonly (ItemKey | BucketKey)[]>>;
 }
 
-interface TableWrites {
-	readonly relid: number;
-	readonly relname: string;
-	readonly writes: number;
-}
-
 export const withChangeCoverage = Effect.fn("Changes.withChangeCoverage")(function* <A, E, R>(
 	body: Effect.Effect<A, E, R>,
 	options?: ChangeCoverage,
@@ -25,7 +19,9 @@ export const withChangeCoverage = Effect.fn("Changes.withChangeCoverage")(functi
 	const named = new Set<unknown>();
 	const declarations = new Map<string, { keys: Set<string>; rows: number }>();
 	const outer = yield* ChangeDeclarations;
-	const written = sql<TableWrites>`select relid, relname, (n_tup_ins + n_tup_upd + n_tup_del)::int as writes from pg_stat_xact_user_tables`;
+	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;