🚀 Socket Launch Week Day 5:Introducing Repository Access Permissions and Custom Roles.Learn more →

@effect/sql-pg

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@effect/sql-pg - npm Package Compare versions

Comparing version

0.50.3

4.0.0-beta.0

+12

dist/index.d.ts

		/**
		* @since 1.0.0
		*/
		/**
		* @since 1.0.0
		*/
		export * as PgClient from "./PgClient.ts";
		/**
		* @since 1.0.0
		*/
		export * as PgMigrator from "./PgMigrator.ts";
		//# sourceMappingURL=index.d.ts.map

+1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;GAEG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}

+13

dist/index.js

		/**
		* @since 1.0.0
		*/
		// @barrel: Auto-generated exports. Do not edit manually.
		/**
		* @since 1.0.0
		*/
		export * as PgClient from "./PgClient.js";
		/**
		* @since 1.0.0
		*/
		export * as PgMigrator from "./PgMigrator.js";
		//# sourceMappingURL=index.js.map

+1

dist/index.js.map

{"version":3,"file":"index.js","names":["PgClient","PgMigrator"],"sources":["../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;AAGA,OAAO,KAAKA,QAAQ,MAAM,eAAe;AAEzC;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB","ignoreList":[]}

+132

dist/PgClient.d.ts

		import * as Config from "effect/Config";
		import * as Duration from "effect/Duration";
		import * as Effect from "effect/Effect";
		import * as Layer from "effect/Layer";
		import * as Redacted from "effect/Redacted";
		import * as Scope from "effect/Scope";
		import * as ServiceMap from "effect/ServiceMap";
		import * as Stream from "effect/Stream";
		import * as Reactivity from "effect/unstable/reactivity/Reactivity";
		import * as Client from "effect/unstable/sql/SqlClient";
		import { SqlError } from "effect/unstable/sql/SqlError";
		import type { Custom, Fragment } from "effect/unstable/sql/Statement";
		import * as Statement from "effect/unstable/sql/Statement";
		import type { Duplex } from "node:stream";
		import type { ConnectionOptions } from "node:tls";
		import * as Pg from "pg";
		/**
		* @category type ids
		* @since 1.0.0
		*/
		export declare const TypeId: TypeId;
		/**
		* @category type ids
		* @since 1.0.0
		*/
		export type TypeId = "~@effect/sql-pg/PgClient";
		/**
		* @category models
		* @since 1.0.0
		*/
		export interface PgClient extends Client.SqlClient {
		readonly [TypeId]: TypeId;
		readonly config: PgClientConfig;
		readonly json: (_: unknown) => Fragment;
		readonly listen: (channel: string) => Stream.Stream<string, SqlError>;
		readonly notify: (channel: string, payload: string) => Effect.Effect<void, SqlError>;
		}
		/**
		* @category tags
		* @since 1.0.0
		*/
		export declare const PgClient: ServiceMap.Service<PgClient, PgClient>;
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export interface PgClientConfig {
		readonly url?: Redacted.Redacted \| undefined;
		readonly host?: string \| undefined;
		readonly port?: number \| undefined;
		readonly path?: string \| undefined;
		readonly ssl?: boolean \| ConnectionOptions \| undefined;
		readonly database?: string \| undefined;
		readonly username?: string \| undefined;
		readonly password?: Redacted.Redacted \| undefined;
		readonly stream?: (() => Duplex) \| undefined;
		readonly idleTimeout?: Duration.DurationInput \| undefined;
		readonly connectTimeout?: Duration.DurationInput \| undefined;
		readonly maxConnections?: number \| undefined;
		readonly minConnections?: number \| undefined;
		readonly connectionTTL?: Duration.DurationInput \| undefined;
		readonly applicationName?: string \| undefined;
		readonly spanAttributes?: Record<string, unknown> \| undefined;
		readonly transformResultNames?: ((str: string) => string) \| undefined;
		readonly transformQueryNames?: ((str: string) => string) \| undefined;
		readonly transformJson?: boolean \| undefined;
		readonly types?: Pg.CustomTypesConfig \| undefined;
		}
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export declare const make: (options: PgClientConfig) => Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity>;
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export declare const fromPool: (options: {
		readonly acquire: Effect.Effect<Pg.Pool, SqlError, Scope.Scope>;
		readonly applicationName?: string \| undefined;
		readonly spanAttributes?: Record<string, unknown> \| undefined;
		readonly transformResultNames?: ((str: string) => string) \| undefined;
		readonly transformQueryNames?: ((str: string) => string) \| undefined;
		readonly transformJson?: boolean \| undefined;
		readonly types?: Pg.CustomTypesConfig \| undefined;
		}) => Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layerConfig: (config: Config.Wrap<PgClientConfig>) => Layer.Layer<PgClient \| Client.SqlClient, Config.ConfigError \| SqlError>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layer: (config: PgClientConfig) => Layer.Layer<PgClient \| Client.SqlClient, SqlError>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layerFromPool: (options: {
		readonly acquire: Effect.Effect<Pg.Pool, SqlError, Scope.Scope>;
		readonly applicationName?: string \| undefined;
		readonly spanAttributes?: Record<string, unknown> \| undefined;
		readonly transformResultNames?: ((str: string) => string) \| undefined;
		readonly transformQueryNames?: ((str: string) => string) \| undefined;
		readonly transformJson?: boolean \| undefined;
		readonly types?: Pg.CustomTypesConfig \| undefined;
		}) => Layer.Layer<PgClient \| Client.SqlClient, SqlError>;
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export declare const makeCompiler: (transform?: (_: string) => string, transformJson?: boolean) => Statement.Compiler;
		/**
		* @category custom types
		* @since 1.0.0
		*/
		export type PgCustom = PgJson;
		/**
		* @category custom types
		* @since 1.0.0
		*/
		interface PgJson extends Custom<"PgJson", unknown> {
		}
		/**
		* @category custom types
		* @since 1.0.0
		*/
		declare const PgJson: (paramA: unknown, paramB: void, paramC: void) => PgJson;
		export {};
		//# sourceMappingURL=PgClient.d.ts.map

+1

dist/PgClient.d.ts.map

+394

dist/PgClient.js

		/**
		* @since 1.0.0
		*/
		import * as Arr from "effect/Array";
		import * as Cause from "effect/Cause";
		import * as Channel from "effect/Channel";
		import * as Config from "effect/Config";
		import * as Duration from "effect/Duration";
		import * as Effect from "effect/Effect";
		import * as Fiber from "effect/Fiber";
		import * as Layer from "effect/Layer";
		import * as Number from "effect/Number";
		import * as Queue from "effect/Queue";
		import * as RcRef from "effect/RcRef";
		import * as Redacted from "effect/Redacted";
		import * as Scope from "effect/Scope";
		import * as ServiceMap from "effect/ServiceMap";
		import * as Stream from "effect/Stream";
		import * as Reactivity from "effect/unstable/reactivity/Reactivity";
		import * as Client from "effect/unstable/sql/SqlClient";
		import { SqlError } from "effect/unstable/sql/SqlError";
		import * as Statement from "effect/unstable/sql/Statement";
		import * as Pg from "pg";
		import * as PgConnString from "pg-connection-string";
		import Cursor from "pg-cursor";
		const ATTR_DB_SYSTEM_NAME = "db.system.name";
		const ATTR_DB_NAMESPACE = "db.namespace";
		const ATTR_SERVER_ADDRESS = "server.address";
		const ATTR_SERVER_PORT = "server.port";
		/**
		* @category type ids
		* @since 1.0.0
		*/
		export const TypeId = "~@effect/sql-pg/PgClient";
		/**
		* @category tags
		* @since 1.0.0
		*/
		export const PgClient = /#__PURE__/ServiceMap.Service("@effect/sql-pg/PgClient");
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export const make = options => fromPool({
		...options,
		acquire: Effect.gen(function* () {
		const pool = new Pg.Pool({
		connectionString: options.url ? Redacted.value(options.url) : undefined,
		user: options.username,
		host: options.host,
		database: options.database,
		password: options.password ? Redacted.value(options.password) : undefined,
		ssl: options.ssl,
		port: options.port,
		...(options.stream ? {
		stream: options.stream
		} : {}),
		connectionTimeoutMillis: options.connectTimeout ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.connectTimeout)) : undefined,
		idleTimeoutMillis: options.idleTimeout ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.idleTimeout)) : undefined,
		max: options.maxConnections,
		min: options.minConnections,
		maxLifetimeSeconds: options.connectionTTL ? Duration.toSeconds(Duration.fromDurationInputUnsafe(options.connectionTTL)) : undefined,
		application_name: options.applicationName ?? "@effect/sql-pg",
		types: options.types
		});
		pool.on("error", _err => {});
		yield* Effect.acquireRelease(Effect.tryPromise({
		try: () => pool.query("SELECT 1"),
		catch: cause => new SqlError({
		cause,
		message: "PgClient: Failed to connect"
		})
		}), () => Effect.promise(() => pool.end()).pipe(Effect.timeoutOption(1000))).pipe(Effect.timeoutOrElse({
		duration: options.connectTimeout ?? Duration.seconds(5),
		onTimeout: () => Effect.fail(new SqlError({
		cause: new Error("Connection timed out"),
		message: "PgClient: Connection timed out"
		}))
		}));
		return pool;
		})
		});
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export const fromPool = /#__PURE__/Effect.fnUntraced(function* (options) {
		const compiler = makeCompiler(options.transformQueryNames, options.transformJson);
		const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames, options.transformJson).array : undefined;
		const pool = yield* options.acquire;
		class ConnectionImpl {
		pg;
		constructor(pg) {
		this.pg = pg;
		}
		runWithClient(f) {
		if (this.pg !== undefined) {
		return Effect.callback(resume => {
		f(this.pg, resume);
		return makeCancel(pool, this.pg);
		});
		}
		return Effect.callback(resume => {
		let done = false;
		let cancel = undefined;
		let client = undefined;
		function onError(cause) {
		cleanup(cause);
		resume(Effect.fail(new SqlError({
		cause,
		message: "Connection error"
		})));
		}
		function cleanup(cause) {
		if (!done) client?.release(cause);
		done = true;
		client?.off("error", onError);
		}
		pool.connect((cause, client_) => {
		if (cause) {
		return resume(Effect.fail(new SqlError({
		cause,
		message: "Failed to acquire connection"
		})));
		} else if (!client_) {
		return resume(Effect.fail(new SqlError({
		message: "Failed to acquire connection",
		cause: new Error("No client returned")
		})));
		} else if (done) {
		client_.release();
		return;
		}
		client = client_;
		client.once("error", onError);
		cancel = makeCancel(pool, client);
		f(client, eff => {
		cleanup();
		resume(eff);
		});
		});
		return Effect.suspend(() => {
		if (!cancel) {
		cleanup();
		return Effect.void;
		}
		return Effect.ensuring(cancel, Effect.sync(cleanup));
		});
		});
		}
		run(query, params) {
		return this.runWithClient((client, resume) => {
		client.query(query, params, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		// Multi-statement queries return an array of results
		resume(Effect.succeed(Array.isArray(result) ? result.map(r => r.rows ?? []) : result.rows ?? []));
		}
		});
		});
		}
		execute(sql, params, transformRows) {
		return transformRows ? Effect.map(this.run(sql, params), transformRows) : this.run(sql, params);
		}
		executeRaw(sql, params) {
		return this.runWithClient((client, resume) => {
		client.query(sql, params, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		resume(Effect.succeed(result));
		}
		});
		});
		}
		executeWithoutTransform(sql, params) {
		return this.run(sql, params);
		}
		executeValues(sql, params) {
		return this.runWithClient((client, resume) => {
		client.query({
		text: sql,
		rowMode: "array",
		values: params
		}, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		resume(Effect.succeed(result.rows));
		}
		});
		});
		}
		executeUnprepared(sql, params, transformRows) {
		return this.execute(sql, params, transformRows);
		}
		executeStream(sql, params, transformRows) {
		// oxlint-disable-next-line @typescript-eslint/no-this-alias
		const self = this;
		return Stream.fromChannel(Channel.fromTransform(Effect.fnUntraced(function* (_, scope) {
		const client = self.pg ?? (yield* Scope.provide(reserveRaw, scope));
		yield* Scope.addFinalizer(scope, Effect.promise(() => cursor.close()));
		const cursor = client.query(new Cursor(sql, params));
		// @effect-diagnostics-next-line returnEffectInGen:off
		return Effect.callback(resume => {
		cursor.read(128, (err, rows) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else if (Arr.isArrayNonEmpty(rows)) {
		resume(Effect.succeed(transformRows ? transformRows(rows) : rows));
		} else {
		resume(Cause.done());
		}
		});
		});
		})));
		}
		}
		const reserveRaw = Effect.callback(resume => {
		const fiber = Fiber.getCurrent();
		const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope);
		let cause = undefined;
		pool.connect((err, client, release) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to acquire connection for transaction"
		})));
		} else {
		resume(Effect.as(Scope.addFinalizer(scope, Effect.sync(() => {
		client.off("error", onError);
		release(cause);
		})), client));
		}
		function onError(cause_) {
		cause = cause_;
		}
		client.on("error", onError);
		});
		});
		const reserve = Effect.map(reserveRaw, client => new ConnectionImpl(client));
		const listenClient = yield* RcRef.make({
		acquire: reserveRaw
		});
		let config = {
		url: pool.options.connectionString ? Redacted.make(pool.options.connectionString) : undefined,
		host: pool.options.host,
		port: pool.options.port,
		database: pool.options.database,
		username: pool.options.user,
		password: typeof pool.options.password === "string" ? Redacted.make(pool.options.password) : undefined,
		ssl: pool.options.ssl,
		applicationName: pool.options.application_name,
		types: pool.options.types
		};
		if (pool.options.connectionString) {
		// @effect-diagnostics-next-line tryCatchInEffectGen:off
		try {
		const parsed = PgConnString.parse(pool.options.connectionString);
		config = {
		...config,
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Number.parse(parsed.port) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
		database: config.database ?? parsed.database ?? undefined
		};
		} catch {
		//
		}
		}
		return Object.assign(yield* Client.make({
		acquirer: Effect.succeed(new ConnectionImpl()),
		transactionAcquirer: reserve,
		compiler,
		spanAttributes: [...(options.spanAttributes ? Object.entries(options.spanAttributes) : []), [ATTR_DB_SYSTEM_NAME, "postgresql"], [ATTR_DB_NAMESPACE, config.database ?? config.username ?? "postgres"], [ATTR_SERVER_ADDRESS, config.host ?? "localhost"], [ATTR_SERVER_PORT, config.port ?? 5432]],
		transformRows
		}), {
		[TypeId]: TypeId,
		config,
		json: _ => Statement.fragment([PgJson(_)]),
		listen: channel => Stream.callback(Effect.fnUntraced(function* (queue) {
		const client = yield* RcRef.get(listenClient);
		function onNotification(msg) {
		if (msg.channel === channel && msg.payload) {
		Queue.offerUnsafe(queue, msg.payload);
		}
		}
		yield* Effect.addFinalizer(() => Effect.promise(() => {
		client.off("notification", onNotification);
		return client.query(`UNLISTEN ${Pg.escapeIdentifier(channel)}`);
		}));
		yield* Effect.tryPromise({
		try: () => client.query(`LISTEN ${Pg.escapeIdentifier(channel)}`),
		catch: cause => new SqlError({
		cause,
		message: "Failed to listen"
		})
		});
		client.on("notification", onNotification);
		})),
		notify: (channel, payload) => Effect.callback(resume => {
		pool.query(`NOTIFY ${Pg.escapeIdentifier(channel)}, $1`, [payload], err => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to notify"
		})));
		} else {
		resume(Effect.void);
		}
		});
		})
		});
		});
		const cancelEffects = /#__PURE__/new WeakMap();
		const makeCancel = (pool, client) => {
		if (cancelEffects.has(client)) {
		return cancelEffects.get(client);
		}
		const processId = client.processID;
		const eff = processId !== undefined
		// query cancelation is best-effort, so we don't fail if it doesn't work
		? Effect.callback(resume => {
		if (pool.ending) return resume(Effect.void);
		pool.query(`SELECT pg_cancel_backend(${processId})`, () => {
		resume(Effect.void);
		});
		}).pipe(Effect.interruptible, Effect.timeoutOption(5000)) : undefined;
		cancelEffects.set(client, eff);
		return eff;
		};
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layerConfig = config => Layer.effectServices(Config.unwrap(config).asEffect().pipe(Effect.flatMap(make), Effect.map(client => ServiceMap.make(PgClient, client).pipe(ServiceMap.add(Client.SqlClient, client))))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layer = config => Layer.effectServices(Effect.map(make(config), client => ServiceMap.make(PgClient, client).pipe(ServiceMap.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layerFromPool = options => Layer.effectServices(Effect.map(fromPool(options), client => ServiceMap.make(PgClient, client).pipe(ServiceMap.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export const makeCompiler = (transform, transformJson = true) => {
		const transformValue = transformJson && transform ? Statement.defaultTransforms(transform).value : undefined;
		return Statement.makeCompiler({
		dialect: "pg",
		placeholder(_) {
		return `$${_}`;
		},
		onIdentifier: transform ? function (value, withoutTransform) {
		return withoutTransform ? escape(value) : escape(transform(value));
		} : escape,
		onRecordUpdate(placeholders, valueAlias, valueColumns, values, returning) {
		return [`(values ${placeholders}) AS ${valueAlias}${valueColumns}${returning ? ` RETURNING ${returning[0]}` : ""}`, returning ? values.flat().concat(returning[1]) : values.flat()];
		},
		onCustom(type, placeholder, withoutTransform) {
		switch (type.kind) {
		case "PgJson":
		{
		return [placeholder(undefined), [withoutTransform \|\| transformValue === undefined ? type.paramA : transformValue(type.paramA)]];
		}
		}
		}
		});
		};
		const escape = /#__PURE__/Statement.defaultEscape("\"");
		/**
		* @category custom types
		* @since 1.0.0
		*/
		const PgJson = /#__PURE__/Statement.custom("PgJson");
		//# sourceMappingURL=PgClient.js.map

+1

dist/PgClient.js.map

+23

dist/PgMigrator.d.ts

		/**
		* @since 1.0.0
		*/
		import type * as Effect from "effect/Effect";
		import * as Layer from "effect/Layer";
		import * as Migrator from "effect/unstable/sql/Migrator";
		import type * as Client from "effect/unstable/sql/SqlClient";
		import type { SqlError } from "effect/unstable/sql/SqlError";
		/**
		* @since 1.0.0
		*/
		export * from "effect/unstable/sql/Migrator";
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export declare const run: <R2 = never>(options: Migrator.MigratorOptions<R2>) => Effect.Effect<ReadonlyArray<readonly [id: number, name: string]>, Migrator.MigrationError \| SqlError, Client.SqlClient \| R2>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layer: <R>(options: Migrator.MigratorOptions<R>) => Layer.Layer<never, Migrator.MigrationError \| SqlError, Client.SqlClient \| R>;
		//# sourceMappingURL=PgMigrator.d.ts.map

+1

dist/PgMigrator.d.ts.map

{"version":3,"file":"PgMigrator.d.ts","sourceRoot":"","sources":["../src/PgMigrator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,8BAA8B,CAAA;AACxD,OAAO,KAAK,KAAK,MAAM,MAAM,+BAA+B,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAE5D;;GAEG;AACH,cAAc,8BAA8B,CAAA;AAE5C;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,EAC3B,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,KAClC,MAAM,CAAC,MAAM,CAChB,aAAa,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAClD,QAAQ,CAAC,cAAc,GAAG,QAAQ,EAClC,MAAM,CAAC,SAAS,GAAG,EAAE,CA0DrB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,SAAS,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,KACnC,KAAK,CAAC,KAAK,CACZ,KAAK,EACL,QAAQ,CAAC,cAAc,GAAG,QAAQ,EAClC,MAAM,CAAC,SAAS,GAAG,CAAC,CACgB,CAAA"}

+74

dist/PgMigrator.js

		import * as Layer from "effect/Layer";
		import * as Migrator from "effect/unstable/sql/Migrator";
		/**
		* @since 1.0.0
		*/
		export * from "effect/unstable/sql/Migrator";
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export const run = /#__PURE__/Migrator.make({
		// TODO: Wait for Command module
		// dumpSchema(path, table) {
		// const pgDump = (args: Array<string>) =>
		// Effect.gen(function*() {
		// const sql = yield* PgClient
		// const dump = yield* pipe(
		// Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"),
		// Command.env({
		// PATH: (globalThis as any).process?.env.PATH,
		// PGHOST: sql.config.host,
		// PGPORT: sql.config.port?.toString(),
		// PGUSER: sql.config.username,
		// PGPASSWORD: sql.config.password
		// ? Redacted.value(sql.config.password)
		// : undefined,
		// PGDATABASE: sql.config.database,
		// PGSSLMODE: sql.config.ssl ? "require" : "prefer"
		// }),
		// Command.string
		// )
		//
		// return dump.replace(/^--.*$/gm, "")
		// .replace(/^SET .*$/gm, "")
		// .replace(/^SELECT pg_catalog\..*$/gm, "")
		// .replace(/\n{2,}/gm, "\n\n")
		// .trim()
		// }).pipe(
		// Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
		// )
		//
		// const pgDumpSchema = pgDump(["--schema-only"])
		//
		// const pgDumpMigrations = pgDump([
		// "--column-inserts",
		// "--data-only",
		// `--table=${table}`
		// ])
		//
		// const pgDumpAll = Effect.map(
		// Effect.all([pgDumpSchema, pgDumpMigrations], { concurrency: 2 }),
		// ([schema, migrations]) => schema + "\n\n" + migrations
		// )
		//
		// const pgDumpFile = (path: string) =>
		// Effect.gen(function*() {
		// const fs = yield* FileSystem
		// const path_ = yield* Path
		// const dump = yield* pgDumpAll
		// yield* fs.makeDirectory(path_.dirname(path), { recursive: true })
		// yield* fs.writeFileString(path, dump)
		// }).pipe(
		// Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
		// )
		//
		// return pgDumpFile(path)
		// }
		});
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layer = options => Layer.effectDiscard(run(options));
		//# sourceMappingURL=PgMigrator.js.map

+1

dist/PgMigrator.js.map

{"version":3,"file":"PgMigrator.js","names":["Layer","Migrator","run","make","layer","options","effectDiscard"],"sources":["../src/PgMigrator.ts"],"sourcesContent":[null],"mappings":"AAIA,OAAO,KAAKA,KAAK,MAAM,cAAc;AACrC,OAAO,KAAKC,QAAQ,MAAM,8BAA8B;AAIxD;;;AAGA,cAAc,8BAA8B;AAE5C;;;;AAIA,OAAO,MAAMC,GAAG,gBAMZD,QAAQ,CAACE,IAAI,CAAC;EAChB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;AAAA,CACD,CAAC;AAEF;;;;AAIA,OAAO,MAAMC,KAAK,GAChBC,OAAoC,IAKjCL,KAAK,CAACM,aAAa,CAACJ,GAAG,CAACG,OAAO,CAAC,CAAC","ignoreList":[]}

+56

-54

package.json

		{
		"name": "@effect/sql-pg",
		"version": "0.50.3",
		"version": "4.0.0-beta.0",
		"type": "module",
		"license": "MIT",
		"description": "A PostgreSQL toolkit for Effect",
		"license": "MIT",
		"homepage": "https://effect.website",
		"repository": {
		"type": "git",
		"url": "https://github.com/Effect-TS/effect.git",
		"directory": "packages/sql-pg"
		"url": "https://github.com/Effect-TS/effect-smol.git",
		"directory": "packages/sql/pg"
		},
		"bugs": {
		"url": "https://github.com/Effect-TS/effect-smol/issues"
		},
		"tags": [
		"typescript",
		"sql",
		"database"
		],
		"keywords": [
		"typescript",
		"sql",
		"database"
		],
		"sideEffects": [],
		"homepage": "https://effect.website",
		"dependencies": {
		"pg": "^8.16.3",
		"pg-connection-string": "2.9.1",
		"pg-cursor": "^2.15.3",
		"pg-pool": "^3.10.1",
		"pg-types": "^4.1.0"
		"exports": {
		"./package.json": "./package.json",
		".": "./dist/index.js",
		"./": "./dist/.js",
		"./internal/*": null,
		"./*/index": null
		},
		"peerDependencies": {
		"@effect/experimental": "^0.58.0",
		"@effect/platform": "^0.94.4",
		"@effect/sql": "^0.49.0",
		"effect": "^3.19.16"
		},
		"files": [
		"src/*/.ts",
		"dist/*/.js",
		"dist/*/.js.map",
		"dist/*/.d.ts",
		"dist/*/.d.ts.map"
		],
		"publishConfig": {
		"access": "public",
		"provenance": true
		},
		"main": "./dist/cjs/index.js",
		"module": "./dist/esm/index.js",
		"types": "./dist/dts/index.d.ts",
		"exports": {
		"./package.json": "./package.json",
		".": {
		"types": "./dist/dts/index.d.ts",
		"import": "./dist/esm/index.js",
		"default": "./dist/cjs/index.js"
		},
		"./PgClient": {
		"types": "./dist/dts/PgClient.d.ts",
		"import": "./dist/esm/PgClient.js",
		"default": "./dist/cjs/PgClient.js"
		},
		"./PgMigrator": {
		"types": "./dist/dts/PgMigrator.d.ts",
		"import": "./dist/esm/PgMigrator.js",
		"default": "./dist/cjs/PgMigrator.js"
		},
		"./index": {
		"types": "./dist/dts/index.d.ts",
		"import": "./dist/esm/index.js",
		"default": "./dist/cjs/index.js"
		}
		"devDependencies": {
		"@testcontainers/postgresql": "^11.11.0",
		"@types/pg": "^8.16.0",
		"@types/pg-cursor": "^2.7.2",
		"effect": "^4.0.0-beta.0"
		},
		"typesVersions": {
		"*": {
		"PgClient": [
		"./dist/dts/PgClient.d.ts"
		],
		"PgMigrator": [
		"./dist/dts/PgMigrator.d.ts"
		],
		"index": [
		"./dist/dts/index.d.ts"
		]
		}
		"peerDependencies": {
		"effect": "^4.0.0-beta.0"
		},
		"dependencies": {
		"pg": "^8.18.0",
		"pg-connection-string": "2.11.0",
		"pg-cursor": "^2.17.0",
		"pg-pool": "^3.11.0",
		"pg-types": "^4.1.0"
		},
		"scripts": {
		"codegen": "effect-utils codegen",
		"build": "tsc -b tsconfig.json && pnpm babel",
		"build:tsgo": "tsgo -b tsconfig.json && pnpm babel",
		"babel": "babel dist --plugins annotate-pure-calls --out-dir dist --source-maps",
		"check": "tsc -b tsconfig.json",
		"test": "vitest",
		"coverage": "vitest --coverage"
		}
		}

+8

-2

src/index.ts

		/**
		* @since 1.0.0
		*/
		export * as PgClient from "./PgClient.js"

		// @barrel: Auto-generated exports. Do not edit manually.

		/**
		* @since 1.0.0
		*/
		export * as PgMigrator from "./PgMigrator.js"
		export * as PgClient from "./PgClient.ts"

		/**
		* @since 1.0.0
		*/
		export * as PgMigrator from "./PgMigrator.ts"

+331

-376

src/PgClient.ts

		/**
		* @since 1.0.0
		*/
		import * as Reactivity from "@effect/experimental/Reactivity"
		import * as Client from "@effect/sql/SqlClient"
		import type { Connection } from "@effect/sql/SqlConnection"
		import { SqlError } from "@effect/sql/SqlError"
		import type { Custom, Fragment } from "@effect/sql/Statement"
		import * as Statement from "@effect/sql/Statement"
		import * as Arr from "effect/Array"
		import * as Chunk from "effect/Chunk"
		import * as Cause from "effect/Cause"
		import * as Channel from "effect/Channel"
		import * as Config from "effect/Config"
		import type * as ConfigError from "effect/ConfigError"
		import * as Context from "effect/Context"
		import * as Duration from "effect/Duration"
		@@ -20,7 +13,14 @@ import * as Effect from "effect/Effect"
		import * as Number from "effect/Number"
		import * as Option from "effect/Option"
		import * as Queue from "effect/Queue"
		import * as RcRef from "effect/RcRef"
		import * as Redacted from "effect/Redacted"
		import * as Scope from "effect/Scope"
		import * as ServiceMap from "effect/ServiceMap"
		import * as Stream from "effect/Stream"
		import * as Reactivity from "effect/unstable/reactivity/Reactivity"
		import * as Client from "effect/unstable/sql/SqlClient"
		import type { Connection } from "effect/unstable/sql/SqlConnection"
		import { SqlError } from "effect/unstable/sql/SqlError"
		import type { Custom, Fragment } from "effect/unstable/sql/Statement"
		import * as Statement from "effect/unstable/sql/Statement"
		import type { Duplex } from "node:stream"
		@@ -65,3 +65,3 @@ import type { ConnectionOptions } from "node:tls"
		*/
		export const PgClient = Context.GenericTag<PgClient>("@effect/sql-pg/PgClient")
		export const PgClient = ServiceMap.Service<PgClient>("@effect/sql-pg/PgClient")

		@@ -101,203 +101,251 @@ /**

		type ClientOptions = {
		readonly spanAttributes?: Record<string, unknown> \| undefined
		readonly transformResultNames?: ((str: string) => string) \| undefined
		readonly transformQueryNames?: ((str: string) => string) \| undefined
		readonly transformJson?: boolean \| undefined
		}
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export const make = (
		options: PgClientConfig
		): Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity> =>
		fromPool({
		...options,
		acquire: Effect.gen(function*() {
		const pool = new Pg.Pool({
		connectionString: options.url ? Redacted.value(options.url) : undefined,
		user: options.username,
		host: options.host,
		database: options.database,
		password: options.password ? Redacted.value(options.password) : undefined,
		ssl: options.ssl,
		port: options.port,
		...(options.stream ? { stream: options.stream } : {}),
		connectionTimeoutMillis: options.connectTimeout
		? Duration.toMillis(Duration.fromDurationInputUnsafe(options.connectTimeout))
		: undefined,
		idleTimeoutMillis: options.idleTimeout
		? Duration.toMillis(Duration.fromDurationInputUnsafe(options.idleTimeout))
		: undefined,
		max: options.maxConnections,
		min: options.minConnections,
		maxLifetimeSeconds: options.connectionTTL
		? Duration.toSeconds(Duration.fromDurationInputUnsafe(options.connectionTTL))
		: undefined,
		application_name: options.applicationName ?? "@effect/sql-pg",
		types: options.types
		})

		const makeClient = (
		pool: Pg.Pool,
		config: PgClientConfig,
		options: ClientOptions
		): Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity> =>
		Effect.gen(function*() {
		const compiler = makeCompiler(
		options.transformQueryNames,
		pool.on("error", (_err) => {})

		yield* Effect.acquireRelease(
		Effect.tryPromise({
		try: () => pool.query("SELECT 1"),
		catch: (cause) => new SqlError({ cause, message: "PgClient: Failed to connect" })
		}),
		() =>
		Effect.promise(() => pool.end()).pipe(
		Effect.timeoutOption(1000)
		)
		).pipe(
		Effect.timeoutOrElse({
		duration: options.connectTimeout ?? Duration.seconds(5),
		onTimeout: () =>
		Effect.fail(
		new SqlError({
		cause: new Error("Connection timed out"),
		message: "PgClient: Connection timed out"
		})
		)
		})
		)

		return pool
		})
		})

		/**
		* @category constructors
		* @since 1.0.0
		*/
		export const fromPool = Effect.fnUntraced(function*(
		options: {
		readonly acquire: Effect.Effect<Pg.Pool, SqlError, Scope.Scope>

		readonly applicationName?: string \| undefined
		readonly spanAttributes?: Record<string, unknown> \| undefined

		readonly transformResultNames?: ((str: string) => string) \| undefined
		readonly transformQueryNames?: ((str: string) => string) \| undefined
		readonly transformJson?: boolean \| undefined
		readonly types?: Pg.CustomTypesConfig \| undefined
		}
		): Effect.fn.Return<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity> {
		const compiler = makeCompiler(
		options.transformQueryNames,
		options.transformJson
		)
		const transformRows = options.transformResultNames ?
		Statement.defaultTransforms(
		options.transformResultNames,
		options.transformJson
		)
		const transformRows = options.transformResultNames ?
		Statement.defaultTransforms(
		options.transformResultNames,
		options.transformJson
		).array :
		undefined
		).array :
		undefined

		class ConnectionImpl implements Connection {
		readonly pg: Pg.PoolClient \| undefined
		constructor(pg?: Pg.PoolClient) {
		this.pg = pg
		const pool = yield* options.acquire

		class ConnectionImpl implements Connection {
		readonly pg: Pg.PoolClient \| undefined
		constructor(pg?: Pg.PoolClient) {
		this.pg = pg
		}

		private runWithClient<A>(f: (client: Pg.PoolClient, resume: (_: Effect.Effect<A, SqlError>) => void) => void) {
		if (this.pg !== undefined) {
		return Effect.callback<A, SqlError>((resume) => {
		f(this.pg!, resume)
		return makeCancel(pool, this.pg!)
		})
		}

		private runWithClient<A>(f: (client: Pg.PoolClient, resume: (_: Effect.Effect<A, SqlError>) => void) => void) {
		if (this.pg !== undefined) {
		return Effect.async<A, SqlError>((resume) => {
		f(this.pg!, resume)
		return makeCancel(pool, this.pg!)
		})
		return Effect.callback<A, SqlError>((resume) => {
		let done = false
		let cancel: Effect.Effect<void> \| undefined = undefined
		let client: Pg.PoolClient \| undefined = undefined
		function onError(cause: Error) {
		cleanup(cause)
		resume(Effect.fail(new SqlError({ cause, message: "Connection error" })))
		}
		return Effect.async<A, SqlError>((resume) => {
		let done = false
		let cancel: Effect.Effect<void> \| undefined = undefined
		let client: Pg.PoolClient \| undefined = undefined
		function onError(cause: Error) {
		cleanup(cause)
		resume(Effect.fail(new SqlError({ cause, message: "Connection error" })))
		function cleanup(cause?: Error) {
		if (!done) client?.release(cause)
		done = true
		client?.off("error", onError)
		}
		pool.connect((cause, client_) => {
		if (cause) {
		return resume(Effect.fail(new SqlError({ cause, message: "Failed to acquire connection" })))
		} else if (!client_) {
		return resume(
		Effect.fail(
		new SqlError({ message: "Failed to acquire connection", cause: new Error("No client returned") })
		)
		)
		} else if (done) {
		client_.release()
		return
		}
		function cleanup(cause?: Error) {
		if (!done) client?.release(cause)
		done = true
		client?.off("error", onError)
		}
		pool.connect((cause, client_) => {
		if (cause) {
		return resume(Effect.fail(new SqlError({ cause, message: "Failed to acquire connection" })))
		} else if (!client_) {
		return resume(
		Effect.fail(
		new SqlError({ message: "Failed to acquire connection", cause: new Error("No client returned") })
		)
		)
		} else if (done) {
		client_.release()
		return
		}
		client = client_
		client.once("error", onError)
		cancel = makeCancel(pool, client)
		f(client, (eff) => {
		cleanup()
		resume(eff)
		})
		client = client_
		client.once("error", onError)
		cancel = makeCancel(pool, client)
		f(client, (eff) => {
		cleanup()
		resume(eff)
		})
		return Effect.suspend(() => {
		if (!cancel) {
		cleanup()
		return Effect.void
		}
		return Effect.ensuring(cancel, Effect.sync(cleanup))
		})
		})
		}
		return Effect.suspend(() => {
		if (!cancel) {
		cleanup()
		return Effect.void
		}
		return Effect.ensuring(cancel, Effect.sync(cleanup))
		})
		})
		}

		private run(query: string, params: ReadonlyArray<unknown>) {
		return this.runWithClient<ReadonlyArray<any>>((client, resume) => {
		client.query(query, params as any, (err, result) => {
		private run(query: string, params: ReadonlyArray<unknown>) {
		return this.runWithClient<ReadonlyArray<any>>((client, resume) => {
		client.query(query, params as any, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to execute statement" })))
		} else {
		// Multi-statement queries return an array of results
		resume(Effect.succeed(
		Array.isArray(result)
		? result.map((r) => r.rows ?? [])
		: result.rows ?? []
		))
		}
		})
		})
		}

		execute(
		sql: string,
		params: ReadonlyArray<unknown>,
		transformRows: (<A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A>) \| undefined
		) {
		return transformRows
		? Effect.map(this.run(sql, params), transformRows)
		: this.run(sql, params)
		}
		executeRaw(sql: string, params: ReadonlyArray<unknown>) {
		return this.runWithClient<Pg.Result>((client, resume) => {
		client.query(sql, params as any, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to execute statement" })))
		} else {
		resume(Effect.succeed(result))
		}
		})
		})
		}
		executeWithoutTransform(sql: string, params: ReadonlyArray<unknown>) {
		return this.run(sql, params)
		}
		executeValues(sql: string, params: ReadonlyArray<unknown>) {
		return this.runWithClient<ReadonlyArray<any>>((client, resume) => {
		client.query(
		{
		text: sql,
		rowMode: "array",
		values: params as Array<string>
		},
		(err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to execute statement" })))
		} else {
		// Multi-statement queries return an array of results
		resume(Effect.succeed(
		Array.isArray(result)
		? result.map((r) => r.rows ?? [])
		: result.rows ?? []
		))
		resume(Effect.succeed(result.rows))
		}
		})
		})
		}

		execute(
		sql: string,
		params: ReadonlyArray<unknown>,
		transformRows: (<A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A>) \| undefined
		) {
		return transformRows
		? Effect.map(this.run(sql, params), transformRows)
		: this.run(sql, params)
		}
		executeRaw(sql: string, params: ReadonlyArray<unknown>) {
		return this.runWithClient<Pg.Result>((client, resume) => {
		client.query(sql, params as any, (err, result) => {
		}
		)
		})
		}
		executeUnprepared(
		sql: string,
		params: ReadonlyArray<unknown>,
		transformRows: (<A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A>) \| undefined
		) {
		return this.execute(sql, params, transformRows)
		}
		executeStream(
		sql: string,
		params: ReadonlyArray<unknown>,
		transformRows: (<A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A>) \| undefined
		) {
		// oxlint-disable-next-line @typescript-eslint/no-this-alias
		const self = this
		return Stream.fromChannel(Channel.fromTransform(Effect.fnUntraced(function*(_, scope) {
		const client = self.pg ?? (yield* Scope.provide(reserveRaw, scope))
		yield* Scope.addFinalizer(scope, Effect.promise(() => cursor.close()))
		const cursor = client.query(new Cursor(sql, params as any))
		// @effect-diagnostics-next-line returnEffectInGen:off
		return Effect.callback<Arr.NonEmptyReadonlyArray<any>, SqlError \| Cause.Done>((resume) => {
		cursor.read(128, (err, rows) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to execute statement" })))
		} else if (Arr.isArrayNonEmpty(rows)) {
		resume(Effect.succeed(transformRows ? transformRows(rows) as any : rows))
		} else {
		resume(Effect.succeed(result))
		resume(Cause.done())
		}
		})
		})
		}
		executeWithoutTransform(sql: string, params: ReadonlyArray<unknown>) {
		return this.run(sql, params)
		}
		executeValues(sql: string, params: ReadonlyArray<unknown>) {
		return this.runWithClient<ReadonlyArray<any>>((client, resume) => {
		client.query(
		{
		text: sql,
		rowMode: "array",
		values: params as Array<string>
		},
		(err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to execute statement" })))
		} else {
		resume(Effect.succeed(result.rows))
		}
		}
		)
		})
		}
		executeUnprepared(
		sql: string,
		params: ReadonlyArray<unknown>,
		transformRows: (<A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A>) \| undefined
		) {
		return this.execute(sql, params, transformRows)
		}
		executeStream(
		sql: string,
		params: ReadonlyArray<unknown>,
		transformRows: (<A extends object>(row: ReadonlyArray<A>) => ReadonlyArray<A>) \| undefined
		) {
		// eslint-disable-next-line @typescript-eslint/no-this-alias
		const self = this
		return Effect.gen(function*() {
		const scope = yield* Effect.scope
		const client = self.pg ?? (yield* reserveRaw)
		yield* Scope.addFinalizer(scope, Effect.promise(() => cursor.close()))
		const cursor = client.query(new Cursor(sql, params as any))
		const pull = Effect.async<Chunk.Chunk<any>, Option.Option<SqlError>>((resume) => {
		cursor.read(128, (err, rows) => {
		if (err) {
		resume(Effect.fail(Option.some(new SqlError({ cause: err, message: "Failed to execute statement" }))))
		} else if (Arr.isNonEmptyArray(rows)) {
		resume(Effect.succeed(Chunk.unsafeFromArray(transformRows ? transformRows(rows) as any : rows)))
		} else {
		resume(Effect.fail(Option.none()))
		}
		})
		})
		return Stream.repeatEffectChunkOption(pull)
		}).pipe(
		Stream.unwrapScoped
		)
		}
		})))
		}
		}

		const reserveRaw = Effect.async<Pg.PoolClient, SqlError, Scope.Scope>((resume) => {
		const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
		const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope)
		let cause: Error \| undefined = undefined
		function onError(cause_: Error) {
		cause = cause_
		}
		pool.connect((err, client, release) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to acquire connection for transaction" })))
		return
		} else if (!client) {
		resume(
		Effect.fail(
		new SqlError({
		message: "Failed to acquire connection for transaction",
		cause: new Error("No client returned")
		})
		)
		)
		return
		}

		// Else we know we have client defined, so we can proceed with the connection
		client.on("error", onError)
		const reserveRaw = Effect.callback<Pg.PoolClient, SqlError, Scope.Scope>((resume) => {
		const fiber = Fiber.getCurrent()!
		const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
		let cause: Error \| undefined = undefined
		pool.connect((err, client, release) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to acquire connection for transaction" })))
		} else {
		resume(Effect.as(
		@@ -307,173 +355,21 @@ Scope.addFinalizer(
		Effect.sync(() => {
		client.off("error", onError)
		client!.off("error", onError)
		release(cause)
		})
		),
		client
		client!
		))
		})
		}
		function onError(cause_: Error) {
		cause = cause_
		}
		client!.on("error", onError)
		})
		const reserve = Effect.map(reserveRaw, (client) => new ConnectionImpl(client))

		const listenClient = yield* RcRef.make({
		acquire: reserveRaw
		})

		return Object.assign(
		yield* Client.make({
		acquirer: Effect.succeed(new ConnectionImpl()),
		transactionAcquirer: reserve,
		compiler,
		spanAttributes: [
		...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
		[ATTR_DB_SYSTEM_NAME, "postgresql"],
		[ATTR_DB_NAMESPACE, config.database ?? config.username ?? "postgres"],
		[ATTR_SERVER_ADDRESS, config.host ?? "localhost"],
		[ATTR_SERVER_PORT, config.port ?? 5432]
		],
		transformRows
		}),
		{
		[TypeId]: TypeId as TypeId,
		config,
		json: (_: unknown) => PgJson(_),
		listen: (channel: string) =>
		Stream.asyncPush<string, SqlError>(Effect.fnUntraced(function*(emit) {
		const client = yield* RcRef.get(listenClient)
		function onNotification(msg: Pg.Notification) {
		if (msg.channel === channel && msg.payload) {
		emit.single(msg.payload)
		}
		}
		yield* Effect.addFinalizer(() =>
		Effect.promise(() => {
		client.off("notification", onNotification)
		return client.query(`UNLISTEN ${Pg.escapeIdentifier(channel)}`)
		})
		)
		yield* Effect.tryPromise({
		try: () => client.query(`LISTEN ${Pg.escapeIdentifier(channel)}`),
		catch: (cause) => new SqlError({ cause, message: "Failed to listen" })
		})
		client.on("notification", onNotification)
		})),
		notify: (channel: string, payload: string) =>
		Effect.async<void, SqlError>((resume) => {
		pool.query(`NOTIFY ${Pg.escapeIdentifier(channel)}, $1`, [payload], (err) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to notify" })))
		} else {
		resume(Effect.void)
		}
		})
		})
		}
		)
		})
		const reserve = Effect.map(reserveRaw, (client) => new ConnectionImpl(client))

		/**
		* @category constructors
		* @since 1.0.0
		*/
		export const make = (
		options: PgClientConfig
		): Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity> =>
		Effect.gen(function*() {
		const pool = new Pg.Pool({
		connectionString: options.url ? Redacted.value(options.url) : undefined,
		user: options.username,
		host: options.host,
		database: options.database,
		password: options.password ? Redacted.value(options.password) : undefined,
		ssl: options.ssl,
		port: options.port,
		...(options.stream ? { stream: options.stream } : {}),
		connectionTimeoutMillis: options.connectTimeout
		? Duration.toMillis(options.connectTimeout)
		: undefined,
		idleTimeoutMillis: options.idleTimeout
		? Duration.toMillis(options.idleTimeout)
		: undefined,
		max: options.maxConnections,
		min: options.minConnections,
		maxLifetimeSeconds: options.connectionTTL
		? Duration.toSeconds(options.connectionTTL)
		: undefined,
		application_name: options.applicationName ?? "@effect/sql-pg",
		types: options.types
		})

		pool.on("error", (_err) => {
		})

		yield* Effect.acquireRelease(
		Effect.tryPromise({
		try: () => pool.query("SELECT 1"),
		catch: (cause) => new SqlError({ cause, message: "PgClient: Failed to connect" })
		}),
		() =>
		Effect.promise(() => pool.end()).pipe(
		Effect.interruptible,
		Effect.timeoutOption(1000)
		)
		).pipe(
		Effect.timeoutFail({
		duration: options.connectTimeout ?? Duration.seconds(5),
		onTimeout: () =>
		new SqlError({
		cause: new Error("Connection timed out"),
		message: "PgClient: Connection timed out"
		})
		})
		)

		let config = options
		if (pool.options.connectionString) {
		try {
		const parsed = PgConnString.parse(pool.options.connectionString)
		config = {
		...config,
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
		database: config.database ?? parsed.database ?? undefined
		}
		} catch {
		//
		}
		}

		return yield* makeClient(pool, config, options)
		const listenClient = yield* RcRef.make({
		acquire: reserveRaw
		})

		/**
		* @category constructors
		* @since 1.0.0
		*/
		export interface PgClientFromPoolOptions {
		readonly acquire: Effect.Effect<Pg.Pool, SqlError, Scope.Scope>

		readonly applicationName?: string \| undefined
		readonly spanAttributes?: Record<string, unknown> \| undefined

		readonly transformResultNames?: ((str: string) => string) \| undefined
		readonly transformQueryNames?: ((str: string) => string) \| undefined
		readonly transformJson?: boolean \| undefined
		readonly types?: Pg.CustomTypesConfig \| undefined
		}

		/**
		* Create a `PgClient` from an existing `pg` pool.
		*
		* You control the pool lifecycle via `acquire` (typically `Effect.acquireRelease`).
		*
		* @category constructors
		* @since 1.0.0
		*/
		export const fromPool = Effect.fnUntraced(function*(
		options: PgClientFromPoolOptions
		): Effect.fn.Return<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity> {
		const pool = yield* options.acquire

		let config: PgClientConfig = {
		@@ -487,7 +383,7 @@ url: pool.options.connectionString ? Redacted.make(pool.options.connectionString) : undefined,
		ssl: pool.options.ssl,
		applicationName: (pool.options as any).application_name,
		applicationName: pool.options.application_name,
		types: pool.options.types
		}

		if (pool.options.connectionString) {
		// @effect-diagnostics-next-line tryCatchInEffectGen:off
		try {
		@@ -498,3 +394,3 @@ const parsed = PgConnString.parse(pool.options.connectionString)
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
		port: config.port ?? (parsed.port ? Number.parse(parsed.port) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		@@ -509,3 +405,52 @@ password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),

		return yield* makeClient(pool, config, options)
		return Object.assign(
		yield* Client.make({
		acquirer: Effect.succeed(new ConnectionImpl()),
		transactionAcquirer: reserve,
		compiler,
		spanAttributes: [
		...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
		[ATTR_DB_SYSTEM_NAME, "postgresql"],
		[ATTR_DB_NAMESPACE, config.database ?? config.username ?? "postgres"],
		[ATTR_SERVER_ADDRESS, config.host ?? "localhost"],
		[ATTR_SERVER_PORT, config.port ?? 5432]
		],
		transformRows
		}),
		{
		[TypeId]: TypeId as TypeId,
		config,
		json: (_: unknown) => Statement.fragment([PgJson(_)]),
		listen: (channel: string) =>
		Stream.callback<string, SqlError>(Effect.fnUntraced(function*(queue) {
		const client = yield* RcRef.get(listenClient)
		function onNotification(msg: Pg.Notification) {
		if (msg.channel === channel && msg.payload) {
		Queue.offerUnsafe(queue, msg.payload)
		}
		}
		yield* Effect.addFinalizer(() =>
		Effect.promise(() => {
		client.off("notification", onNotification)
		return client.query(`UNLISTEN ${Pg.escapeIdentifier(channel)}`)
		})
		)
		yield* Effect.tryPromise({
		try: () => client.query(`LISTEN ${Pg.escapeIdentifier(channel)}`),
		catch: (cause) => new SqlError({ cause, message: "Failed to listen" })
		})
		client.on("notification", onNotification)
		})),
		notify: (channel: string, payload: string) =>
		Effect.callback<void, SqlError>((resume) => {
		pool.query(`NOTIFY ${Pg.escapeIdentifier(channel)}, $1`, [payload], (err) => {
		if (err) {
		resume(Effect.fail(new SqlError({ cause: err, message: "Failed to notify" })))
		} else {
		resume(Effect.void)
		}
		})
		})
		}
		)
		})
		@@ -521,3 +466,3 @@
		// query cancelation is best-effort, so we don't fail if it doesn't work
		? Effect.async<void>((resume) => {
		? Effect.callback<void>((resume) => {
		if (pool.ending) return resume(Effect.void)
		@@ -540,11 +485,13 @@ pool.query(`SELECT pg_cancel_backend(${processId})`, () => {
		*/
		export const layerConfig = (
		config: Config.Config.Wrap<PgClientConfig>
		): Layer.Layer<PgClient \| Client.SqlClient, ConfigError.ConfigError \| SqlError> =>
		Layer.scopedContext(
		Config.unwrap(config).pipe(
		export const layerConfig: (
		config: Config.Wrap<PgClientConfig>
		) => Layer.Layer<PgClient \| Client.SqlClient, Config.ConfigError \| SqlError> = (
		config: Config.Wrap<PgClientConfig>
		): Layer.Layer<PgClient \| Client.SqlClient, Config.ConfigError \| SqlError> =>
		Layer.effectServices(
		Config.unwrap(config).asEffect().pipe(
		Effect.flatMap(make),
		Effect.map((client) =>
		Context.make(PgClient, client).pipe(
		Context.add(Client.SqlClient, client)
		ServiceMap.make(PgClient, client).pipe(
		ServiceMap.add(Client.SqlClient, client)
		)
		@@ -562,6 +509,6 @@ )
		): Layer.Layer<PgClient \| Client.SqlClient, SqlError> =>
		Layer.scopedContext(
		Layer.effectServices(
		Effect.map(make(config), (client) =>
		Context.make(PgClient, client).pipe(
		Context.add(Client.SqlClient, client)
		ServiceMap.make(PgClient, client).pipe(
		ServiceMap.add(Client.SqlClient, client)
		))
		@@ -574,9 +521,17 @@ ).pipe(Layer.provide(Reactivity.layer))
		*/
		export const layerFromPool = (
		options: PgClientFromPoolOptions
		): Layer.Layer<PgClient \| Client.SqlClient, SqlError> =>
		Layer.scopedContext(
		export const layerFromPool = (options: {
		readonly acquire: Effect.Effect<Pg.Pool, SqlError, Scope.Scope>

		readonly applicationName?: string \| undefined
		readonly spanAttributes?: Record<string, unknown> \| undefined

		readonly transformResultNames?: ((str: string) => string) \| undefined
		readonly transformQueryNames?: ((str: string) => string) \| undefined
		readonly transformJson?: boolean \| undefined
		readonly types?: Pg.CustomTypesConfig \| undefined
		}): Layer.Layer<PgClient \| Client.SqlClient, SqlError> =>
		Layer.effectServices(
		Effect.map(fromPool(options), (client) =>
		Context.make(PgClient, client).pipe(
		Context.add(Client.SqlClient, client)
		ServiceMap.make(PgClient, client).pipe(
		ServiceMap.add(Client.SqlClient, client)
		))
		@@ -622,4 +577,4 @@ ).pipe(Layer.provide(Reactivity.layer))
		withoutTransform \|\| transformValue === undefined
		? type.i0
		: transformValue(type.i0)
		? type.paramA
		: transformValue(type.paramA)
		]
		@@ -626,0 +581,0 @@ ]

+63

-74

src/PgMigrator.ts

		/**
		* @since 1.0.0
		*/
		import * as Command from "@effect/platform/Command"
		import type { CommandExecutor } from "@effect/platform/CommandExecutor"
		import { FileSystem } from "@effect/platform/FileSystem"
		import { Path } from "@effect/platform/Path"
		import * as Migrator from "@effect/sql/Migrator"
		import type * as Client from "@effect/sql/SqlClient"
		import type { SqlError } from "@effect/sql/SqlError"
		import * as Effect from "effect/Effect"
		import { pipe } from "effect/Function"
		import type * as Effect from "effect/Effect"
		import * as Layer from "effect/Layer"
		import * as Redacted from "effect/Redacted"
		import { PgClient } from "./PgClient.js"
		import * as Migrator from "effect/unstable/sql/Migrator"
		import type * as Client from "effect/unstable/sql/SqlClient"
		import type { SqlError } from "effect/unstable/sql/SqlError"

		@@ -20,10 +13,5 @@ /**
		*/
		export * from "@effect/sql/Migrator"
		export * from "effect/unstable/sql/Migrator"

		/**
		* @since 1.0.0
		*/
		export * from "@effect/sql/Migrator/FileSystem"

		/**
		* @category constructor
		@@ -37,59 +25,60 @@ * @since 1.0.0
		Migrator.MigrationError \| SqlError,
		FileSystem \| Path \| PgClient \| Client.SqlClient \| CommandExecutor \| R2
		Client.SqlClient \| R2
		> = Migrator.make({
		dumpSchema(path, table) {
		const pgDump = (args: Array<string>) =>
		Effect.gen(function*() {
		const sql = yield* PgClient
		const dump = yield* pipe(
		Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"),
		Command.env({
		PATH: (globalThis as any).process?.env.PATH,
		PGHOST: sql.config.host,
		PGPORT: sql.config.port?.toString(),
		PGUSER: sql.config.username,
		PGPASSWORD: sql.config.password
		? Redacted.value(sql.config.password)
		: undefined,
		PGDATABASE: sql.config.database,
		PGSSLMODE: sql.config.ssl ? "require" : "prefer"
		}),
		Command.string
		)

		return dump.replace(/^--.*$/gm, "")
		.replace(/^SET .*$/gm, "")
		.replace(/^SELECT pg_catalog\..*$/gm, "")
		.replace(/\n{2,}/gm, "\n\n")
		.trim();
		}).pipe(
		Effect.mapError((error) => new Migrator.MigrationError({ reason: "failed", message: error.message }))
		)

		const pgDumpSchema = pgDump(["--schema-only"])

		const pgDumpMigrations = pgDump([
		"--column-inserts",
		"--data-only",
		`--table=${table}`
		])

		const pgDumpAll = Effect.map(
		Effect.all([pgDumpSchema, pgDumpMigrations], { concurrency: 2 }),
		([schema, migrations]) => schema + "\n\n" + migrations
		)

		const pgDumpFile = (path: string) =>
		Effect.gen(function*() {
		const fs = yield* FileSystem
		const path_ = yield* Path
		const dump = yield* pgDumpAll
		yield* fs.makeDirectory(path_.dirname(path), { recursive: true })
		yield* fs.writeFileString(path, dump)
		}).pipe(
		Effect.mapError((error) => new Migrator.MigrationError({ reason: "failed", message: error.message }))
		)

		return pgDumpFile(path)
		}
		// TODO: Wait for Command module
		// dumpSchema(path, table) {
		// const pgDump = (args: Array<string>) =>
		// Effect.gen(function*() {
		// const sql = yield* PgClient
		// const dump = yield* pipe(
		// Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"),
		// Command.env({
		// PATH: (globalThis as any).process?.env.PATH,
		// PGHOST: sql.config.host,
		// PGPORT: sql.config.port?.toString(),
		// PGUSER: sql.config.username,
		// PGPASSWORD: sql.config.password
		// ? Redacted.value(sql.config.password)
		// : undefined,
		// PGDATABASE: sql.config.database,
		// PGSSLMODE: sql.config.ssl ? "require" : "prefer"
		// }),
		// Command.string
		// )
		//
		// return dump.replace(/^--.*$/gm, "")
		// .replace(/^SET .*$/gm, "")
		// .replace(/^SELECT pg_catalog\..*$/gm, "")
		// .replace(/\n{2,}/gm, "\n\n")
		// .trim()
		// }).pipe(
		// Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
		// )
		//
		// const pgDumpSchema = pgDump(["--schema-only"])
		//
		// const pgDumpMigrations = pgDump([
		// "--column-inserts",
		// "--data-only",
		// `--table=${table}`
		// ])
		//
		// const pgDumpAll = Effect.map(
		// Effect.all([pgDumpSchema, pgDumpMigrations], { concurrency: 2 }),
		// ([schema, migrations]) => schema + "\n\n" + migrations
		// )
		//
		// const pgDumpFile = (path: string) =>
		// Effect.gen(function*() {
		// const fs = yield* FileSystem
		// const path_ = yield* Path
		// const dump = yield* pgDumpAll
		// yield* fs.makeDirectory(path_.dirname(path), { recursive: true })
		// yield* fs.writeFileString(path, dump)
		// }).pipe(
		// Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
		// )
		//
		// return pgDumpFile(path)
		// }
		})
		@@ -106,3 +95,3 @@
		Migrator.MigrationError \| SqlError,
		PgClient \| Client.SqlClient \| CommandExecutor \| FileSystem \| Path \| R
		Client.SqlClient \| R
		> => Layer.effectDiscard(run(options))

-12

dist/cjs/index.js

		"use strict";

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.PgMigrator = exports.PgClient = void 0;
		var _PgClient = _interopRequireWildcard(require("./PgClient.js"));
		exports.PgClient = _PgClient;
		var _PgMigrator = _interopRequireWildcard(require("./PgMigrator.js"));
		exports.PgMigrator = _PgMigrator;
		function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e \|\| "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get \|\| i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
		//# sourceMappingURL=index.js.map

-1

dist/cjs/index.js.map

{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"","ignoreList":[]}

-434

dist/cjs/PgClient.js

		"use strict";

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.makeCompiler = exports.make = exports.layerFromPool = exports.layerConfig = exports.layer = exports.fromPool = exports.TypeId = exports.PgClient = void 0;
		var Reactivity = _interopRequireWildcard(require("@effect/experimental/Reactivity"));
		var Client = _interopRequireWildcard(require("@effect/sql/SqlClient"));
		var _SqlError = require("@effect/sql/SqlError");
		var Statement = _interopRequireWildcard(require("@effect/sql/Statement"));
		var Arr = _interopRequireWildcard(require("effect/Array"));
		var Chunk = _interopRequireWildcard(require("effect/Chunk"));
		var Config = _interopRequireWildcard(require("effect/Config"));
		var Context = _interopRequireWildcard(require("effect/Context"));
		var Duration = _interopRequireWildcard(require("effect/Duration"));
		var Effect = _interopRequireWildcard(require("effect/Effect"));
		var Fiber = _interopRequireWildcard(require("effect/Fiber"));
		var Layer = _interopRequireWildcard(require("effect/Layer"));
		var Number = _interopRequireWildcard(require("effect/Number"));
		var Option = _interopRequireWildcard(require("effect/Option"));
		var RcRef = _interopRequireWildcard(require("effect/RcRef"));
		var Redacted = _interopRequireWildcard(require("effect/Redacted"));
		var Scope = _interopRequireWildcard(require("effect/Scope"));
		var Stream = _interopRequireWildcard(require("effect/Stream"));
		var Pg = _interopRequireWildcard(require("pg"));
		var PgConnString = _interopRequireWildcard(require("pg-connection-string"));
		var _pgCursor = _interopRequireDefault(require("pg-cursor"));
		function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
		function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e \|\| "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get \|\| i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
		/**
		* @since 1.0.0
		*/

		const ATTR_DB_SYSTEM_NAME = "db.system.name";
		const ATTR_DB_NAMESPACE = "db.namespace";
		const ATTR_SERVER_ADDRESS = "server.address";
		const ATTR_SERVER_PORT = "server.port";
		/**
		* @category type ids
		* @since 1.0.0
		*/
		const TypeId = exports.TypeId = "~@effect/sql-pg/PgClient";
		/**
		* @category tags
		* @since 1.0.0
		*/
		const PgClient = exports.PgClient = /#__PURE__/Context.GenericTag("@effect/sql-pg/PgClient");
		const makeClient = (pool, config, options) => Effect.gen(function* () {
		const compiler = makeCompiler(options.transformQueryNames, options.transformJson);
		const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames, options.transformJson).array : undefined;
		class ConnectionImpl {
		pg;
		constructor(pg) {
		this.pg = pg;
		}
		runWithClient(f) {
		if (this.pg !== undefined) {
		return Effect.async(resume => {
		f(this.pg, resume);
		return makeCancel(pool, this.pg);
		});
		}
		return Effect.async(resume => {
		let done = false;
		let cancel = undefined;
		let client = undefined;
		function onError(cause) {
		cleanup(cause);
		resume(Effect.fail(new _SqlError.SqlError({
		cause,
		message: "Connection error"
		})));
		}
		function cleanup(cause) {
		if (!done) client?.release(cause);
		done = true;
		client?.off("error", onError);
		}
		pool.connect((cause, client_) => {
		if (cause) {
		return resume(Effect.fail(new _SqlError.SqlError({
		cause,
		message: "Failed to acquire connection"
		})));
		} else if (!client_) {
		return resume(Effect.fail(new _SqlError.SqlError({
		message: "Failed to acquire connection",
		cause: new Error("No client returned")
		})));
		} else if (done) {
		client_.release();
		return;
		}
		client = client_;
		client.once("error", onError);
		cancel = makeCancel(pool, client);
		f(client, eff => {
		cleanup();
		resume(eff);
		});
		});
		return Effect.suspend(() => {
		if (!cancel) {
		cleanup();
		return Effect.void;
		}
		return Effect.ensuring(cancel, Effect.sync(cleanup));
		});
		});
		}
		run(query, params) {
		return this.runWithClient((client, resume) => {
		client.query(query, params, (err, result) => {
		if (err) {
		resume(Effect.fail(new _SqlError.SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		// Multi-statement queries return an array of results
		resume(Effect.succeed(Array.isArray(result) ? result.map(r => r.rows ?? []) : result.rows ?? []));
		}
		});
		});
		}
		execute(sql, params, transformRows) {
		return transformRows ? Effect.map(this.run(sql, params), transformRows) : this.run(sql, params);
		}
		executeRaw(sql, params) {
		return this.runWithClient((client, resume) => {
		client.query(sql, params, (err, result) => {
		if (err) {
		resume(Effect.fail(new _SqlError.SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		resume(Effect.succeed(result));
		}
		});
		});
		}
		executeWithoutTransform(sql, params) {
		return this.run(sql, params);
		}
		executeValues(sql, params) {
		return this.runWithClient((client, resume) => {
		client.query({
		text: sql,
		rowMode: "array",
		values: params
		}, (err, result) => {
		if (err) {
		resume(Effect.fail(new _SqlError.SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		resume(Effect.succeed(result.rows));
		}
		});
		});
		}
		executeUnprepared(sql, params, transformRows) {
		return this.execute(sql, params, transformRows);
		}
		executeStream(sql, params, transformRows) {
		// eslint-disable-next-line @typescript-eslint/no-this-alias
		const self = this;
		return Effect.gen(function* () {
		const scope = yield* Effect.scope;
		const client = self.pg ?? (yield* reserveRaw);
		yield* Scope.addFinalizer(scope, Effect.promise(() => cursor.close()));
		const cursor = client.query(new _pgCursor.default(sql, params));
		const pull = Effect.async(resume => {
		cursor.read(128, (err, rows) => {
		if (err) {
		resume(Effect.fail(Option.some(new _SqlError.SqlError({
		cause: err,
		message: "Failed to execute statement"
		}))));
		} else if (Arr.isNonEmptyArray(rows)) {
		resume(Effect.succeed(Chunk.unsafeFromArray(transformRows ? transformRows(rows) : rows)));
		} else {
		resume(Effect.fail(Option.none()));
		}
		});
		});
		return Stream.repeatEffectChunkOption(pull);
		}).pipe(Stream.unwrapScoped);
		}
		}
		const reserveRaw = Effect.async(resume => {
		const fiber = Option.getOrThrow(Fiber.getCurrentFiber());
		const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope);
		let cause = undefined;
		function onError(cause_) {
		cause = cause_;
		}
		pool.connect((err, client, release) => {
		if (err) {
		resume(Effect.fail(new _SqlError.SqlError({
		cause: err,
		message: "Failed to acquire connection for transaction"
		})));
		return;
		} else if (!client) {
		resume(Effect.fail(new _SqlError.SqlError({
		message: "Failed to acquire connection for transaction",
		cause: new Error("No client returned")
		})));
		return;
		}
		// Else we know we have client defined, so we can proceed with the connection
		client.on("error", onError);
		resume(Effect.as(Scope.addFinalizer(scope, Effect.sync(() => {
		client.off("error", onError);
		release(cause);
		})), client));
		});
		});
		const reserve = Effect.map(reserveRaw, client => new ConnectionImpl(client));
		const listenClient = yield* RcRef.make({
		acquire: reserveRaw
		});
		return Object.assign(yield* Client.make({
		acquirer: Effect.succeed(new ConnectionImpl()),
		transactionAcquirer: reserve,
		compiler,
		spanAttributes: [...(options.spanAttributes ? Object.entries(options.spanAttributes) : []), [ATTR_DB_SYSTEM_NAME, "postgresql"], [ATTR_DB_NAMESPACE, config.database ?? config.username ?? "postgres"], [ATTR_SERVER_ADDRESS, config.host ?? "localhost"], [ATTR_SERVER_PORT, config.port ?? 5432]],
		transformRows
		}), {
		[TypeId]: TypeId,
		config,
		json: _ => PgJson(_),
		listen: channel => Stream.asyncPush(Effect.fnUntraced(function* (emit) {
		const client = yield* RcRef.get(listenClient);
		function onNotification(msg) {
		if (msg.channel === channel && msg.payload) {
		emit.single(msg.payload);
		}
		}
		yield* Effect.addFinalizer(() => Effect.promise(() => {
		client.off("notification", onNotification);
		return client.query(`UNLISTEN ${Pg.escapeIdentifier(channel)}`);
		}));
		yield* Effect.tryPromise({
		try: () => client.query(`LISTEN ${Pg.escapeIdentifier(channel)}`),
		catch: cause => new _SqlError.SqlError({
		cause,
		message: "Failed to listen"
		})
		});
		client.on("notification", onNotification);
		})),
		notify: (channel, payload) => Effect.async(resume => {
		pool.query(`NOTIFY ${Pg.escapeIdentifier(channel)}, $1`, [payload], err => {
		if (err) {
		resume(Effect.fail(new _SqlError.SqlError({
		cause: err,
		message: "Failed to notify"
		})));
		} else {
		resume(Effect.void);
		}
		});
		})
		});
		});
		/**
		* @category constructors
		* @since 1.0.0
		*/
		const make = options => Effect.gen(function* () {
		const pool = new Pg.Pool({
		connectionString: options.url ? Redacted.value(options.url) : undefined,
		user: options.username,
		host: options.host,
		database: options.database,
		password: options.password ? Redacted.value(options.password) : undefined,
		ssl: options.ssl,
		port: options.port,
		...(options.stream ? {
		stream: options.stream
		} : {}),
		connectionTimeoutMillis: options.connectTimeout ? Duration.toMillis(options.connectTimeout) : undefined,
		idleTimeoutMillis: options.idleTimeout ? Duration.toMillis(options.idleTimeout) : undefined,
		max: options.maxConnections,
		min: options.minConnections,
		maxLifetimeSeconds: options.connectionTTL ? Duration.toSeconds(options.connectionTTL) : undefined,
		application_name: options.applicationName ?? "@effect/sql-pg",
		types: options.types
		});
		pool.on("error", _err => {});
		yield* Effect.acquireRelease(Effect.tryPromise({
		try: () => pool.query("SELECT 1"),
		catch: cause => new _SqlError.SqlError({
		cause,
		message: "PgClient: Failed to connect"
		})
		}), () => Effect.promise(() => pool.end()).pipe(Effect.interruptible, Effect.timeoutOption(1000))).pipe(Effect.timeoutFail({
		duration: options.connectTimeout ?? Duration.seconds(5),
		onTimeout: () => new _SqlError.SqlError({
		cause: new Error("Connection timed out"),
		message: "PgClient: Connection timed out"
		})
		}));
		let config = options;
		if (pool.options.connectionString) {
		try {
		const parsed = PgConnString.parse(pool.options.connectionString);
		config = {
		...config,
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
		database: config.database ?? parsed.database ?? undefined
		};
		} catch {
		//
		}
		}
		return yield* makeClient(pool, config, options);
		});
		/**
		* Create a `PgClient` from an existing `pg` pool.
		*
		* You control the pool lifecycle via `acquire` (typically `Effect.acquireRelease`).
		*
		* @category constructors
		* @since 1.0.0
		*/
		exports.make = make;
		const fromPool = exports.fromPool = /#__PURE__/Effect.fnUntraced(function* (options) {
		const pool = yield* options.acquire;
		let config = {
		url: pool.options.connectionString ? Redacted.make(pool.options.connectionString) : undefined,
		host: pool.options.host,
		port: pool.options.port,
		database: pool.options.database,
		username: pool.options.user,
		password: typeof pool.options.password === "string" ? Redacted.make(pool.options.password) : undefined,
		ssl: pool.options.ssl,
		applicationName: pool.options.application_name,
		types: pool.options.types
		};
		if (pool.options.connectionString) {
		try {
		const parsed = PgConnString.parse(pool.options.connectionString);
		config = {
		...config,
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
		database: config.database ?? parsed.database ?? undefined
		};
		} catch {
		//
		}
		}
		return yield* makeClient(pool, config, options);
		});
		const cancelEffects = /#__PURE__/new WeakMap();
		const makeCancel = (pool, client) => {
		if (cancelEffects.has(client)) {
		return cancelEffects.get(client);
		}
		const processId = client.processID;
		const eff = processId !== undefined
		// query cancelation is best-effort, so we don't fail if it doesn't work
		? Effect.async(resume => {
		if (pool.ending) return resume(Effect.void);
		pool.query(`SELECT pg_cancel_backend(${processId})`, () => {
		resume(Effect.void);
		});
		}).pipe(Effect.interruptible, Effect.timeoutOption(5000)) : undefined;
		cancelEffects.set(client, eff);
		return eff;
		};
		/**
		* @category layers
		* @since 1.0.0
		*/
		const layerConfig = config => Layer.scopedContext(Config.unwrap(config).pipe(Effect.flatMap(make), Effect.map(client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client))))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category layers
		* @since 1.0.0
		*/
		exports.layerConfig = layerConfig;
		const layer = config => Layer.scopedContext(Effect.map(make(config), client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category layers
		* @since 1.0.0
		*/
		exports.layer = layer;
		const layerFromPool = options => Layer.scopedContext(Effect.map(fromPool(options), client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category constructor
		* @since 1.0.0
		*/
		exports.layerFromPool = layerFromPool;
		const makeCompiler = (transform, transformJson = true) => {
		const transformValue = transformJson && transform ? Statement.defaultTransforms(transform).value : undefined;
		return Statement.makeCompiler({
		dialect: "pg",
		placeholder(_) {
		return `$${_}`;
		},
		onIdentifier: transform ? function (value, withoutTransform) {
		return withoutTransform ? escape(value) : escape(transform(value));
		} : escape,
		onRecordUpdate(placeholders, valueAlias, valueColumns, values, returning) {
		return [`(values ${placeholders}) AS ${valueAlias}${valueColumns}${returning ? ` RETURNING ${returning[0]}` : ""}`, returning ? values.flat().concat(returning[1]) : values.flat()];
		},
		onCustom(type, placeholder, withoutTransform) {
		switch (type.kind) {
		case "PgJson":
		{
		return [placeholder(undefined), [withoutTransform \|\| transformValue === undefined ? type.i0 : transformValue(type.i0)]];
		}
		}
		}
		});
		};
		exports.makeCompiler = makeCompiler;
		const escape = /#__PURE__/Statement.defaultEscape("\"");
		/**
		* @category custom types
		* @since 1.0.0
		*/
		const PgJson = /#__PURE__/Statement.custom("PgJson");
		//# sourceMappingURL=PgClient.js.map

-1

dist/cjs/PgClient.js.map

-104

dist/cjs/PgMigrator.js

		"use strict";

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		var _exportNames = {
		run: true,
		layer: true
		};
		exports.run = exports.layer = void 0;
		var Command = _interopRequireWildcard(require("@effect/platform/Command"));
		var _FileSystem = require("@effect/platform/FileSystem");
		var _Path = require("@effect/platform/Path");
		var Migrator = _interopRequireWildcard(require("@effect/sql/Migrator"));
		Object.keys(Migrator).forEach(function (key) {
		if (key === "default" \|\| key === "__esModule") return;
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		if (key in exports && exports[key] === Migrator[key]) return;
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return Migrator[key];
		}
		});
		});
		var Effect = _interopRequireWildcard(require("effect/Effect"));
		var _Function = require("effect/Function");
		var Layer = _interopRequireWildcard(require("effect/Layer"));
		var Redacted = _interopRequireWildcard(require("effect/Redacted"));
		var _PgClient = require("./PgClient.js");
		var _FileSystem2 = require("@effect/sql/Migrator/FileSystem");
		Object.keys(_FileSystem2).forEach(function (key) {
		if (key === "default" \|\| key === "__esModule") return;
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		if (key in exports && exports[key] === _FileSystem2[key]) return;
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _FileSystem2[key];
		}
		});
		});
		function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e \|\| "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get \|\| i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
		/**
		* @since 1.0.0
		*/

		/**
		* @since 1.0.0
		*/

		/**
		* @since 1.0.0
		*/

		/**
		* @category constructor
		* @since 1.0.0
		*/
		const run = exports.run = /#__PURE__/Migrator.make({
		dumpSchema(path, table) {
		const pgDump = args => Effect.gen(function* () {
		const sql = yield* _PgClient.PgClient;
		const dump = yield* (0, _Function.pipe)(Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"), Command.env({
		PATH: globalThis.process?.env.PATH,
		PGHOST: sql.config.host,
		PGPORT: sql.config.port?.toString(),
		PGUSER: sql.config.username,
		PGPASSWORD: sql.config.password ? Redacted.value(sql.config.password) : undefined,
		PGDATABASE: sql.config.database,
		PGSSLMODE: sql.config.ssl ? "require" : "prefer"
		}), Command.string);
		return dump.replace(/^--.$/gm, "").replace(/^SET .$/gm, "").replace(/^SELECT pg_catalog\..*$/gm, "").replace(/\n{2,}/gm, "\n\n").trim();
		}).pipe(Effect.mapError(error => new Migrator.MigrationError({
		reason: "failed",
		message: error.message
		})));
		const pgDumpSchema = pgDump(["--schema-only"]);
		const pgDumpMigrations = pgDump(["--column-inserts", "--data-only", `--table=${table}`]);
		const pgDumpAll = Effect.map(Effect.all([pgDumpSchema, pgDumpMigrations], {
		concurrency: 2
		}), ([schema, migrations]) => schema + "\n\n" + migrations);
		const pgDumpFile = path => Effect.gen(function* () {
		const fs = yield* _FileSystem.FileSystem;
		const path_ = yield* _Path.Path;
		const dump = yield* pgDumpAll;
		yield* fs.makeDirectory(path_.dirname(path), {
		recursive: true
		});
		yield* fs.writeFileString(path, dump);
		}).pipe(Effect.mapError(error => new Migrator.MigrationError({
		reason: "failed",
		message: error.message
		})));
		return pgDumpFile(path);
		}
		});
		/**
		* @category layers
		* @since 1.0.0
		*/
		const layer = options => Layer.effectDiscard(run(options));
		exports.layer = layer;
		//# sourceMappingURL=PgMigrator.js.map

-1

dist/cjs/PgMigrator.js.map

-9

dist/dts/index.d.ts

		/**
		* @since 1.0.0
		*/
		export * as PgClient from "./PgClient.js";
		/**
		* @since 1.0.0
		*/
		export * as PgMigrator from "./PgMigrator.js";
		//# sourceMappingURL=index.d.ts.map

-1

dist/dts/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;GAEG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}

-137

dist/dts/PgClient.d.ts

		/**
		* @since 1.0.0
		*/
		import * as Reactivity from "@effect/experimental/Reactivity";
		import * as Client from "@effect/sql/SqlClient";
		import { SqlError } from "@effect/sql/SqlError";
		import type { Custom, Fragment } from "@effect/sql/Statement";
		import * as Statement from "@effect/sql/Statement";
		import * as Config from "effect/Config";
		import type * as ConfigError from "effect/ConfigError";
		import * as Context from "effect/Context";
		import * as Duration from "effect/Duration";
		import * as Effect from "effect/Effect";
		import * as Layer from "effect/Layer";
		import * as Redacted from "effect/Redacted";
		import * as Scope from "effect/Scope";
		import * as Stream from "effect/Stream";
		import type { Duplex } from "node:stream";
		import type { ConnectionOptions } from "node:tls";
		import * as Pg from "pg";
		/**
		* @category type ids
		* @since 1.0.0
		*/
		export declare const TypeId: TypeId;
		/**
		* @category type ids
		* @since 1.0.0
		*/
		export type TypeId = "~@effect/sql-pg/PgClient";
		/**
		* @category models
		* @since 1.0.0
		*/
		export interface PgClient extends Client.SqlClient {
		readonly [TypeId]: TypeId;
		readonly config: PgClientConfig;
		readonly json: (_: unknown) => Fragment;
		readonly listen: (channel: string) => Stream.Stream<string, SqlError>;
		readonly notify: (channel: string, payload: string) => Effect.Effect<void, SqlError>;
		}
		/**
		* @category tags
		* @since 1.0.0
		*/
		export declare const PgClient: Context.Tag<PgClient, PgClient>;
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export interface PgClientConfig {
		readonly url?: Redacted.Redacted \| undefined;
		readonly host?: string \| undefined;
		readonly port?: number \| undefined;
		readonly path?: string \| undefined;
		readonly ssl?: boolean \| ConnectionOptions \| undefined;
		readonly database?: string \| undefined;
		readonly username?: string \| undefined;
		readonly password?: Redacted.Redacted \| undefined;
		readonly stream?: (() => Duplex) \| undefined;
		readonly idleTimeout?: Duration.DurationInput \| undefined;
		readonly connectTimeout?: Duration.DurationInput \| undefined;
		readonly maxConnections?: number \| undefined;
		readonly minConnections?: number \| undefined;
		readonly connectionTTL?: Duration.DurationInput \| undefined;
		readonly applicationName?: string \| undefined;
		readonly spanAttributes?: Record<string, unknown> \| undefined;
		readonly transformResultNames?: ((str: string) => string) \| undefined;
		readonly transformQueryNames?: ((str: string) => string) \| undefined;
		readonly transformJson?: boolean \| undefined;
		readonly types?: Pg.CustomTypesConfig \| undefined;
		}
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export declare const make: (options: PgClientConfig) => Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity>;
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export interface PgClientFromPoolOptions {
		readonly acquire: Effect.Effect<Pg.Pool, SqlError, Scope.Scope>;
		readonly applicationName?: string \| undefined;
		readonly spanAttributes?: Record<string, unknown> \| undefined;
		readonly transformResultNames?: ((str: string) => string) \| undefined;
		readonly transformQueryNames?: ((str: string) => string) \| undefined;
		readonly transformJson?: boolean \| undefined;
		readonly types?: Pg.CustomTypesConfig \| undefined;
		}
		/**
		* Create a `PgClient` from an existing `pg` pool.
		*
		* You control the pool lifecycle via `acquire` (typically `Effect.acquireRelease`).
		*
		* @category constructors
		* @since 1.0.0
		*/
		export declare const fromPool: (options: PgClientFromPoolOptions) => Effect.Effect<PgClient, SqlError, Scope.Scope \| Reactivity.Reactivity>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layerConfig: (config: Config.Config.Wrap<PgClientConfig>) => Layer.Layer<PgClient \| Client.SqlClient, ConfigError.ConfigError \| SqlError>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layer: (config: PgClientConfig) => Layer.Layer<PgClient \| Client.SqlClient, SqlError>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layerFromPool: (options: PgClientFromPoolOptions) => Layer.Layer<PgClient \| Client.SqlClient, SqlError>;
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export declare const makeCompiler: (transform?: (_: string) => string, transformJson?: boolean) => Statement.Compiler;
		/**
		* @category custom types
		* @since 1.0.0
		*/
		export type PgCustom = PgJson;
		/**
		* @category custom types
		* @since 1.0.0
		*/
		interface PgJson extends Custom<"PgJson", unknown> {
		}
		/**
		* @category custom types
		* @since 1.0.0
		*/
		declare const PgJson: (i0: unknown, i1: void, i2: void) => Fragment;
		export {};
		//# sourceMappingURL=PgClient.d.ts.map

-1

dist/dts/PgClient.d.ts.map

-28

dist/dts/PgMigrator.d.ts

		import type { CommandExecutor } from "@effect/platform/CommandExecutor";
		import { FileSystem } from "@effect/platform/FileSystem";
		import { Path } from "@effect/platform/Path";
		import * as Migrator from "@effect/sql/Migrator";
		import type * as Client from "@effect/sql/SqlClient";
		import type { SqlError } from "@effect/sql/SqlError";
		import * as Effect from "effect/Effect";
		import * as Layer from "effect/Layer";
		import { PgClient } from "./PgClient.js";
		/**
		* @since 1.0.0
		*/
		export * from "@effect/sql/Migrator";
		/**
		* @since 1.0.0
		*/
		export * from "@effect/sql/Migrator/FileSystem";
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export declare const run: <R2 = never>(options: Migrator.MigratorOptions<R2>) => Effect.Effect<ReadonlyArray<readonly [id: number, name: string]>, Migrator.MigrationError \| SqlError, FileSystem \| Path \| PgClient \| Client.SqlClient \| CommandExecutor \| R2>;
		/**
		* @category layers
		* @since 1.0.0
		*/
		export declare const layer: <R>(options: Migrator.MigratorOptions<R>) => Layer.Layer<never, Migrator.MigrationError \| SqlError, PgClient \| Client.SqlClient \| CommandExecutor \| FileSystem \| Path \| R>;
		//# sourceMappingURL=PgMigrator.d.ts.map

-1

dist/dts/PgMigrator.d.ts.map

{"version":3,"file":"PgMigrator.d.ts","sourceRoot":"","sources":["../../src/PgMigrator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAC5C,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC;;GAEG;AACH,cAAc,sBAAsB,CAAA;AAEpC;;GAEG;AACH,cAAc,iCAAiC,CAAA;AAE/C;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,EAC3B,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,KAClC,MAAM,CAAC,MAAM,CAChB,aAAa,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAClD,QAAQ,CAAC,cAAc,GAAG,QAAQ,EAClC,UAAU,GAAG,IAAI,GAAG,QAAQ,GAAG,MAAM,CAAC,SAAS,GAAG,eAAe,GAAG,EAAE,CAyDtE,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,SAAS,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,KACnC,KAAK,CAAC,KAAK,CACZ,KAAK,EACL,QAAQ,CAAC,cAAc,GAAG,QAAQ,EAClC,QAAQ,GAAG,MAAM,CAAC,SAAS,GAAG,eAAe,GAAG,UAAU,GAAG,IAAI,GAAG,CAAC,CACjC,CAAA"}

-9

dist/esm/index.js

		/**
		* @since 1.0.0
		*/
		export * as PgClient from "./PgClient.js";
		/**
		* @since 1.0.0
		*/
		export * as PgMigrator from "./PgMigrator.js";
		//# sourceMappingURL=index.js.map

-1

dist/esm/index.js.map

{"version":3,"file":"index.js","names":["PgClient","PgMigrator"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,QAAQ,MAAM,eAAe;AAEzC;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB","ignoreList":[]}

-4

dist/esm/package.json

		{
		"type": "module",
		"sideEffects": []
		}

-420

dist/esm/PgClient.js

		/**
		* @since 1.0.0
		*/
		import * as Reactivity from "@effect/experimental/Reactivity";
		import * as Client from "@effect/sql/SqlClient";
		import { SqlError } from "@effect/sql/SqlError";
		import * as Statement from "@effect/sql/Statement";
		import * as Arr from "effect/Array";
		import * as Chunk from "effect/Chunk";
		import * as Config from "effect/Config";
		import * as Context from "effect/Context";
		import * as Duration from "effect/Duration";
		import * as Effect from "effect/Effect";
		import * as Fiber from "effect/Fiber";
		import * as Layer from "effect/Layer";
		import * as Number from "effect/Number";
		import * as Option from "effect/Option";
		import * as RcRef from "effect/RcRef";
		import * as Redacted from "effect/Redacted";
		import * as Scope from "effect/Scope";
		import * as Stream from "effect/Stream";
		import * as Pg from "pg";
		import * as PgConnString from "pg-connection-string";
		import Cursor from "pg-cursor";
		const ATTR_DB_SYSTEM_NAME = "db.system.name";
		const ATTR_DB_NAMESPACE = "db.namespace";
		const ATTR_SERVER_ADDRESS = "server.address";
		const ATTR_SERVER_PORT = "server.port";
		/**
		* @category type ids
		* @since 1.0.0
		*/
		export const TypeId = "~@effect/sql-pg/PgClient";
		/**
		* @category tags
		* @since 1.0.0
		*/
		export const PgClient = /#__PURE__/Context.GenericTag("@effect/sql-pg/PgClient");
		const makeClient = (pool, config, options) => Effect.gen(function* () {
		const compiler = makeCompiler(options.transformQueryNames, options.transformJson);
		const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames, options.transformJson).array : undefined;
		class ConnectionImpl {
		pg;
		constructor(pg) {
		this.pg = pg;
		}
		runWithClient(f) {
		if (this.pg !== undefined) {
		return Effect.async(resume => {
		f(this.pg, resume);
		return makeCancel(pool, this.pg);
		});
		}
		return Effect.async(resume => {
		let done = false;
		let cancel = undefined;
		let client = undefined;
		function onError(cause) {
		cleanup(cause);
		resume(Effect.fail(new SqlError({
		cause,
		message: "Connection error"
		})));
		}
		function cleanup(cause) {
		if (!done) client?.release(cause);
		done = true;
		client?.off("error", onError);
		}
		pool.connect((cause, client_) => {
		if (cause) {
		return resume(Effect.fail(new SqlError({
		cause,
		message: "Failed to acquire connection"
		})));
		} else if (!client_) {
		return resume(Effect.fail(new SqlError({
		message: "Failed to acquire connection",
		cause: new Error("No client returned")
		})));
		} else if (done) {
		client_.release();
		return;
		}
		client = client_;
		client.once("error", onError);
		cancel = makeCancel(pool, client);
		f(client, eff => {
		cleanup();
		resume(eff);
		});
		});
		return Effect.suspend(() => {
		if (!cancel) {
		cleanup();
		return Effect.void;
		}
		return Effect.ensuring(cancel, Effect.sync(cleanup));
		});
		});
		}
		run(query, params) {
		return this.runWithClient((client, resume) => {
		client.query(query, params, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		// Multi-statement queries return an array of results
		resume(Effect.succeed(Array.isArray(result) ? result.map(r => r.rows ?? []) : result.rows ?? []));
		}
		});
		});
		}
		execute(sql, params, transformRows) {
		return transformRows ? Effect.map(this.run(sql, params), transformRows) : this.run(sql, params);
		}
		executeRaw(sql, params) {
		return this.runWithClient((client, resume) => {
		client.query(sql, params, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		resume(Effect.succeed(result));
		}
		});
		});
		}
		executeWithoutTransform(sql, params) {
		return this.run(sql, params);
		}
		executeValues(sql, params) {
		return this.runWithClient((client, resume) => {
		client.query({
		text: sql,
		rowMode: "array",
		values: params
		}, (err, result) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		})));
		} else {
		resume(Effect.succeed(result.rows));
		}
		});
		});
		}
		executeUnprepared(sql, params, transformRows) {
		return this.execute(sql, params, transformRows);
		}
		executeStream(sql, params, transformRows) {
		// eslint-disable-next-line @typescript-eslint/no-this-alias
		const self = this;
		return Effect.gen(function* () {
		const scope = yield* Effect.scope;
		const client = self.pg ?? (yield* reserveRaw);
		yield* Scope.addFinalizer(scope, Effect.promise(() => cursor.close()));
		const cursor = client.query(new Cursor(sql, params));
		const pull = Effect.async(resume => {
		cursor.read(128, (err, rows) => {
		if (err) {
		resume(Effect.fail(Option.some(new SqlError({
		cause: err,
		message: "Failed to execute statement"
		}))));
		} else if (Arr.isNonEmptyArray(rows)) {
		resume(Effect.succeed(Chunk.unsafeFromArray(transformRows ? transformRows(rows) : rows)));
		} else {
		resume(Effect.fail(Option.none()));
		}
		});
		});
		return Stream.repeatEffectChunkOption(pull);
		}).pipe(Stream.unwrapScoped);
		}
		}
		const reserveRaw = Effect.async(resume => {
		const fiber = Option.getOrThrow(Fiber.getCurrentFiber());
		const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope);
		let cause = undefined;
		function onError(cause_) {
		cause = cause_;
		}
		pool.connect((err, client, release) => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to acquire connection for transaction"
		})));
		return;
		} else if (!client) {
		resume(Effect.fail(new SqlError({
		message: "Failed to acquire connection for transaction",
		cause: new Error("No client returned")
		})));
		return;
		}
		// Else we know we have client defined, so we can proceed with the connection
		client.on("error", onError);
		resume(Effect.as(Scope.addFinalizer(scope, Effect.sync(() => {
		client.off("error", onError);
		release(cause);
		})), client));
		});
		});
		const reserve = Effect.map(reserveRaw, client => new ConnectionImpl(client));
		const listenClient = yield* RcRef.make({
		acquire: reserveRaw
		});
		return Object.assign(yield* Client.make({
		acquirer: Effect.succeed(new ConnectionImpl()),
		transactionAcquirer: reserve,
		compiler,
		spanAttributes: [...(options.spanAttributes ? Object.entries(options.spanAttributes) : []), [ATTR_DB_SYSTEM_NAME, "postgresql"], [ATTR_DB_NAMESPACE, config.database ?? config.username ?? "postgres"], [ATTR_SERVER_ADDRESS, config.host ?? "localhost"], [ATTR_SERVER_PORT, config.port ?? 5432]],
		transformRows
		}), {
		[TypeId]: TypeId,
		config,
		json: _ => PgJson(_),
		listen: channel => Stream.asyncPush(Effect.fnUntraced(function* (emit) {
		const client = yield* RcRef.get(listenClient);
		function onNotification(msg) {
		if (msg.channel === channel && msg.payload) {
		emit.single(msg.payload);
		}
		}
		yield* Effect.addFinalizer(() => Effect.promise(() => {
		client.off("notification", onNotification);
		return client.query(`UNLISTEN ${Pg.escapeIdentifier(channel)}`);
		}));
		yield* Effect.tryPromise({
		try: () => client.query(`LISTEN ${Pg.escapeIdentifier(channel)}`),
		catch: cause => new SqlError({
		cause,
		message: "Failed to listen"
		})
		});
		client.on("notification", onNotification);
		})),
		notify: (channel, payload) => Effect.async(resume => {
		pool.query(`NOTIFY ${Pg.escapeIdentifier(channel)}, $1`, [payload], err => {
		if (err) {
		resume(Effect.fail(new SqlError({
		cause: err,
		message: "Failed to notify"
		})));
		} else {
		resume(Effect.void);
		}
		});
		})
		});
		});
		/**
		* @category constructors
		* @since 1.0.0
		*/
		export const make = options => Effect.gen(function* () {
		const pool = new Pg.Pool({
		connectionString: options.url ? Redacted.value(options.url) : undefined,
		user: options.username,
		host: options.host,
		database: options.database,
		password: options.password ? Redacted.value(options.password) : undefined,
		ssl: options.ssl,
		port: options.port,
		...(options.stream ? {
		stream: options.stream
		} : {}),
		connectionTimeoutMillis: options.connectTimeout ? Duration.toMillis(options.connectTimeout) : undefined,
		idleTimeoutMillis: options.idleTimeout ? Duration.toMillis(options.idleTimeout) : undefined,
		max: options.maxConnections,
		min: options.minConnections,
		maxLifetimeSeconds: options.connectionTTL ? Duration.toSeconds(options.connectionTTL) : undefined,
		application_name: options.applicationName ?? "@effect/sql-pg",
		types: options.types
		});
		pool.on("error", _err => {});
		yield* Effect.acquireRelease(Effect.tryPromise({
		try: () => pool.query("SELECT 1"),
		catch: cause => new SqlError({
		cause,
		message: "PgClient: Failed to connect"
		})
		}), () => Effect.promise(() => pool.end()).pipe(Effect.interruptible, Effect.timeoutOption(1000))).pipe(Effect.timeoutFail({
		duration: options.connectTimeout ?? Duration.seconds(5),
		onTimeout: () => new SqlError({
		cause: new Error("Connection timed out"),
		message: "PgClient: Connection timed out"
		})
		}));
		let config = options;
		if (pool.options.connectionString) {
		try {
		const parsed = PgConnString.parse(pool.options.connectionString);
		config = {
		...config,
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
		database: config.database ?? parsed.database ?? undefined
		};
		} catch {
		//
		}
		}
		return yield* makeClient(pool, config, options);
		});
		/**
		* Create a `PgClient` from an existing `pg` pool.
		*
		* You control the pool lifecycle via `acquire` (typically `Effect.acquireRelease`).
		*
		* @category constructors
		* @since 1.0.0
		*/
		export const fromPool = /#__PURE__/Effect.fnUntraced(function* (options) {
		const pool = yield* options.acquire;
		let config = {
		url: pool.options.connectionString ? Redacted.make(pool.options.connectionString) : undefined,
		host: pool.options.host,
		port: pool.options.port,
		database: pool.options.database,
		username: pool.options.user,
		password: typeof pool.options.password === "string" ? Redacted.make(pool.options.password) : undefined,
		ssl: pool.options.ssl,
		applicationName: pool.options.application_name,
		types: pool.options.types
		};
		if (pool.options.connectionString) {
		try {
		const parsed = PgConnString.parse(pool.options.connectionString);
		config = {
		...config,
		host: config.host ?? parsed.host ?? undefined,
		port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
		username: config.username ?? parsed.user ?? undefined,
		password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
		database: config.database ?? parsed.database ?? undefined
		};
		} catch {
		//
		}
		}
		return yield* makeClient(pool, config, options);
		});
		const cancelEffects = /#__PURE__/new WeakMap();
		const makeCancel = (pool, client) => {
		if (cancelEffects.has(client)) {
		return cancelEffects.get(client);
		}
		const processId = client.processID;
		const eff = processId !== undefined
		// query cancelation is best-effort, so we don't fail if it doesn't work
		? Effect.async(resume => {
		if (pool.ending) return resume(Effect.void);
		pool.query(`SELECT pg_cancel_backend(${processId})`, () => {
		resume(Effect.void);
		});
		}).pipe(Effect.interruptible, Effect.timeoutOption(5000)) : undefined;
		cancelEffects.set(client, eff);
		return eff;
		};
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layerConfig = config => Layer.scopedContext(Config.unwrap(config).pipe(Effect.flatMap(make), Effect.map(client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client))))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layer = config => Layer.scopedContext(Effect.map(make(config), client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layerFromPool = options => Layer.scopedContext(Effect.map(fromPool(options), client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export const makeCompiler = (transform, transformJson = true) => {
		const transformValue = transformJson && transform ? Statement.defaultTransforms(transform).value : undefined;
		return Statement.makeCompiler({
		dialect: "pg",
		placeholder(_) {
		return `$${_}`;
		},
		onIdentifier: transform ? function (value, withoutTransform) {
		return withoutTransform ? escape(value) : escape(transform(value));
		} : escape,
		onRecordUpdate(placeholders, valueAlias, valueColumns, values, returning) {
		return [`(values ${placeholders}) AS ${valueAlias}${valueColumns}${returning ? ` RETURNING ${returning[0]}` : ""}`, returning ? values.flat().concat(returning[1]) : values.flat()];
		},
		onCustom(type, placeholder, withoutTransform) {
		switch (type.kind) {
		case "PgJson":
		{
		return [placeholder(undefined), [withoutTransform \|\| transformValue === undefined ? type.i0 : transformValue(type.i0)]];
		}
		}
		}
		});
		};
		const escape = /#__PURE__/Statement.defaultEscape("\"");
		/**
		* @category custom types
		* @since 1.0.0
		*/
		const PgJson = /#__PURE__/Statement.custom("PgJson");
		//# sourceMappingURL=PgClient.js.map

-1

dist/esm/PgClient.js.map

-68

dist/esm/PgMigrator.js

		/**
		* @since 1.0.0
		*/
		import * as Command from "@effect/platform/Command";
		import { FileSystem } from "@effect/platform/FileSystem";
		import { Path } from "@effect/platform/Path";
		import * as Migrator from "@effect/sql/Migrator";
		import * as Effect from "effect/Effect";
		import { pipe } from "effect/Function";
		import * as Layer from "effect/Layer";
		import * as Redacted from "effect/Redacted";
		import { PgClient } from "./PgClient.js";
		/**
		* @since 1.0.0
		*/
		export * from "@effect/sql/Migrator";
		/**
		* @since 1.0.0
		*/
		export * from "@effect/sql/Migrator/FileSystem";
		/**
		* @category constructor
		* @since 1.0.0
		*/
		export const run = /#__PURE__/Migrator.make({
		dumpSchema(path, table) {
		const pgDump = args => Effect.gen(function* () {
		const sql = yield* PgClient;
		const dump = yield* pipe(Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"), Command.env({
		PATH: globalThis.process?.env.PATH,
		PGHOST: sql.config.host,
		PGPORT: sql.config.port?.toString(),
		PGUSER: sql.config.username,
		PGPASSWORD: sql.config.password ? Redacted.value(sql.config.password) : undefined,
		PGDATABASE: sql.config.database,
		PGSSLMODE: sql.config.ssl ? "require" : "prefer"
		}), Command.string);
		return dump.replace(/^--.$/gm, "").replace(/^SET .$/gm, "").replace(/^SELECT pg_catalog\..*$/gm, "").replace(/\n{2,}/gm, "\n\n").trim();
		}).pipe(Effect.mapError(error => new Migrator.MigrationError({
		reason: "failed",
		message: error.message
		})));
		const pgDumpSchema = pgDump(["--schema-only"]);
		const pgDumpMigrations = pgDump(["--column-inserts", "--data-only", `--table=${table}`]);
		const pgDumpAll = Effect.map(Effect.all([pgDumpSchema, pgDumpMigrations], {
		concurrency: 2
		}), ([schema, migrations]) => schema + "\n\n" + migrations);
		const pgDumpFile = path => Effect.gen(function* () {
		const fs = yield* FileSystem;
		const path_ = yield* Path;
		const dump = yield* pgDumpAll;
		yield* fs.makeDirectory(path_.dirname(path), {
		recursive: true
		});
		yield* fs.writeFileString(path, dump);
		}).pipe(Effect.mapError(error => new Migrator.MigrationError({
		reason: "failed",
		message: error.message
		})));
		return pgDumpFile(path);
		}
		});
		/**
		* @category layers
		* @since 1.0.0
		*/
		export const layer = options => Layer.effectDiscard(run(options));
		//# sourceMappingURL=PgMigrator.js.map

-1

dist/esm/PgMigrator.js.map

{"version":3,"file":"PgMigrator.js","names":["Command","FileSystem","Path","Migrator","Effect","pipe","Layer","Redacted","PgClient","run","make","dumpSchema","path","table","pgDump","args","gen","sql","dump","env","PATH","globalThis","process","PGHOST","config","host","PGPORT","port","toString","PGUSER","username","PGPASSWORD","password","value","undefined","PGDATABASE","database","PGSSLMODE","ssl","string","replace","trim","mapError","error","MigrationError","reason","message","pgDumpSchema","pgDumpMigrations","pgDumpAll","map","all","concurrency","schema","migrations","pgDumpFile","fs","path_","makeDirectory","dirname","recursive","writeFileString","layer","options","effectDiscard"],"sources":["../../src/PgMigrator.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,OAAO,MAAM,0BAA0B;AAEnD,SAASC,UAAU,QAAQ,6BAA6B;AACxD,SAASC,IAAI,QAAQ,uBAAuB;AAC5C,OAAO,KAAKC,QAAQ,MAAM,sBAAsB;AAGhD,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,SAASC,IAAI,QAAQ,iBAAiB;AACtC,OAAO,KAAKC,KAAK,MAAM,cAAc;AACrC,OAAO,KAAKC,QAAQ,MAAM,iBAAiB;AAC3C,SAASC,QAAQ,QAAQ,eAAe;AAExC;;;AAGA,cAAc,sBAAsB;AAEpC;;;AAGA,cAAc,iCAAiC;AAE/C;;;;AAIA,OAAO,MAAMC,GAAG,gBAMZN,QAAQ,CAACO,IAAI,CAAC;EAChBC,UAAUA,CAACC,IAAI,EAAEC,KAAK;IACpB,MAAMC,MAAM,GAAIC,IAAmB,IACjCX,MAAM,CAACY,GAAG,CAAC,aAAS;MAClB,MAAMC,GAAG,GAAG,OAAOT,QAAQ;MAC3B,MAAMU,IAAI,GAAG,OAAOb,IAAI,CACtBL,OAAO,CAACU,IAAI,CAAC,SAAS,EAAE,GAAGK,IAAI,EAAE,YAAY,EAAE,iBAAiB,CAAC,EACjEf,OAAO,CAACmB,GAAG,CAAC;QACVC,IAAI,EAAGC,UAAkB,CAACC,OAAO,EAAEH,GAAG,CAACC,IAAI;QAC3CG,MAAM,EAAEN,GAAG,CAACO,MAAM,CAACC,IAAI;QACvBC,MAAM,EAAET,GAAG,CAACO,MAAM,CAACG,IAAI,EAAEC,QAAQ,EAAE;QACnCC,MAAM,EAAEZ,GAAG,CAACO,MAAM,CAACM,QAAQ;QAC3BC,UAAU,EAAEd,GAAG,CAACO,MAAM,CAACQ,QAAQ,GAC3BzB,QAAQ,CAAC0B,KAAK,CAAChB,GAAG,CAACO,MAAM,CAACQ,QAAQ,CAAC,GACnCE,SAAS;QACbC,UAAU,EAAElB,GAAG,CAACO,MAAM,CAACY,QAAQ;QAC/BC,SAAS,EAAEpB,GAAG,CAACO,MAAM,CAACc,GAAG,GAAG,SAAS,GAAG;OACzC,CAAC,EACFtC,OAAO,CAACuC,MAAM,CACf;MAED,OAAOrB,IAAI,CAACsB,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAChCA,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CACzBA,OAAO,CAAC,2BAA2B,EAAE,EAAE,CAAC,CACxCA,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,CAC3BC,IAAI,EAAE;IACX,CAAC,CAAC,CAACpC,IAAI,CACLD,MAAM,CAACsC,QAAQ,CAAEC,KAAK,IAAK,IAAIxC,QAAQ,CAACyC,cAAc,CAAC;MAAEC,MAAM,EAAE,QAAQ;MAAEC,OAAO,EAAEH,KAAK,CAACG;IAAO,CAAE,CAAC,CAAC,CACtG;IAEH,MAAMC,YAAY,GAAGjC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC;IAE9C,MAAMkC,gBAAgB,GAAGlC,MAAM,CAAC,CAC9B,kBAAkB,EAClB,aAAa,EACb,WAAWD,KAAK,EAAE,CACnB,CAAC;IAEF,MAAMoC,SAAS,GAAG7C,MAAM,CAAC8C,GAAG,CAC1B9C,MAAM,CAAC+C,GAAG,CAAC,CAACJ,YAAY,EAAEC,gBAAgB,CAAC,EAAE;MAAEI,WAAW,EAAE;IAAC,CAAE,CAAC,EAChE,CAAC,CAACC,MAAM,EAAEC,UAAU,CAAC,KAAKD,MAAM,GAAG,MAAM,GAAGC,UAAU,CACvD;IAED,MAAMC,UAAU,GAAI3C,IAAY,IAC9BR,MAAM,CAACY,GAAG,CAAC,aAAS;MAClB,MAAMwC,EAAE,GAAG,OAAOvD,UAAU;MAC5B,MAAMwD,KAAK,GAAG,OAAOvD,IAAI;MACzB,MAAMgB,IAAI,GAAG,OAAO+B,SAAS;MAC7B,OAAOO,EAAE,CAACE,aAAa,CAACD,KAAK,CAACE,OAAO,CAAC/C,IAAI,CAAC,EAAE;QAAEgD,SAAS,EAAE;MAAI,CAAE,CAAC;MACjE,OAAOJ,EAAE,CAACK,eAAe,CAACjD,IAAI,EAAEM,IAAI,CAAC;IACvC,CAAC,CAAC,CAACb,IAAI,CACLD,MAAM,CAACsC,QAAQ,CAAEC,KAAK,IAAK,IAAIxC,QAAQ,CAACyC,cAAc,CAAC;MAAEC,MAAM,EAAE,QAAQ;MAAEC,OAAO,EAAEH,KAAK,CAACG;IAAO,CAAE,CAAC,CAAC,CACtG;IAEH,OAAOS,UAAU,CAAC3C,IAAI,CAAC;EACzB;CACD,CAAC;AAEF;;;;AAIA,OAAO,MAAMkD,KAAK,GAChBC,OAAoC,IAKjCzD,KAAK,CAAC0D,aAAa,CAACvD,GAAG,CAACsD,OAAO,CAAC,CAAC","ignoreList":[]}

-6

index/package.json

		{
		"sideEffects": [],
		"main": "../dist/cjs/index.js",
		"module": "../dist/esm/index.js",
		"types": "../dist/dts/index.d.ts"
		}

-6

PgClient/package.json

		{
		"sideEffects": [],
		"main": "../dist/cjs/PgClient.js",
		"module": "../dist/esm/PgClient.js",
		"types": "../dist/dts/PgClient.d.ts"
		}

-6

PgMigrator/package.json

		{
		"sideEffects": [],
		"main": "../dist/cjs/PgMigrator.js",
		"module": "../dist/esm/PgMigrator.js",
		"types": "../dist/dts/PgMigrator.d.ts"
		}

@effect/sql-pg - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes