@shivaedev/local-postgres 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.9.0 - 2026-11-02
+
+### Fixed
+
+- Pin Docker operations to the validated local endpoint and refuse conflicting Docker host or context settings in the command environment before invoking Docker.
+- Accept PostgreSQL 18.6 distribution version suffixes and leave native server connection limits unchanged when the managed container is unavailable.
+- Return a typed `LocalPostgresError` for malformed URL password escapes instead of a defect.
+
+### Breaking
+
+- `clientConnection` now returns an Effect. Replace direct calls with `yield* clientConnection(url, options)` inside an Effect program so password decoding failures stay in the typed error channel.
+
+## 0.8.0 - 2026-10-31
+
+### Fixed
+
+- Generated applications provide Node services when running database setup, so setup commands participate in Effect interruption and typed failure handling.
+
+### Breaking
+
+- `@shivaedev/local-postgres`: `assertLocalDatabase`, `sql`, `startPostgres`, `prepareDatabases` and lower-level command helpers return Effects. Yield them in an Effect program and provide `ChildProcessSpawner` for commands, for example with `NodeServices.layer` at a Node entry point. Replace synchronous try/catch with Effect error handling. Command failures use `PostgresCommandError`; local-target and image refusals use `LocalPostgresError`. Construct the Schema tagged errors as `new PostgresVersionMismatch({ expectedVersion: "18.6", observedVersion })` or `new PostgresSettingError({ container: "development-postgres", setting: "max_connections", cause })`. Exhausted readiness checks retain their final failure instead of reporting an unobserved version mismatch.
+- `@shivaedev/server`: `setupDatabases()` requires `ChildProcessSpawner` and exposes local PostgreSQL failures in its typed error channel. Provide `NodeServices.layer` at the setup entry point instead of relying on synchronous commands hidden inside the host.
+
 ## 0.7.0 - 2026-10-25
 
 ### Breaking

package/README.md

@@ -7,10 +7,16 @@ Make development and integration tests share one persistent local PostgreSQL ser
 A setup command should make a machine ready to work without erasing the work already on it. Reimplementing PostgreSQL startup in every repository makes that promise harder to keep. This package gives a setup script one place to prepare the service and its databases:
 
 ```ts
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect } from "effect";
 import { LOCAL_SERVER, localPostgres } from "@shivaedev/local-postgres/server/localPostgres.ts";
 
-const development = process.env.DATABASE_URL ?? `${LOCAL_SERVER}/example_dev`;
-localPostgres(process.env).prepareDatabases([development]);
+NodeRuntime.runMain(
+	localPostgres({})
+		.prepareDatabases([`${LOCAL_SERVER}/example_dev`])
+		.pipe(Effect.provide(NodeServices.layer)),
+);
 ```
 
 The application supplies its configured database URL. Preparation checks that the target is local and can run again without losing the data already in the database.
@@ -20,12 +26,11 @@ The application supplies its configured database URL. Preparation checks that th
 ### How to think about it
 
 There are three separate responsibilities:
-
 1. The **service** is PostgreSQL running on the local machine. This package prepares access to it.
 2. A **database** is an application-chosen name on that service. This package creates missing databases; the application chooses their names through configuration or a fixed allowlist.
 3. The **schema and data** belong to the application. Its setup script runs migrations, loads fixtures or seeds data after preparation.
 
-`localPostgres(environment)` returns three synchronous functions: `startPostgres`, `prepareDatabases` and `sql`. Use them in setup tooling. Use your application's database client and `@shivaedev/effect-sql` for persistence and migrations in an Effect application.
+`localPostgres(environment)` returns three functions that produce Effects: `startPostgres`, `prepareDatabases` and `sql`. Yield them in setup tooling, and provide `ChildProcessSpawner` through the Effect environment. `NodeServices.layer` supplies the Node implementation at an entry point; command scopes preserve interruption and readiness waits use Effect’s clock. Use your application's database client and `@shivaedev/sql` for persistence and migrations in an Effect application.
 
 ### 1. Once per application: choose the databases
 
@@ -34,79 +39,87 @@ There are three separate responsibilities:
 When database names come from the application's configured URLs, pass those URLs directly to preparation:
 
 ```ts
+import { Config, Effect } from "effect";
 import { LOCAL_SERVER, localPostgres } from "@shivaedev/local-postgres/server/localPostgres.ts";
 
-const development = process.env.DATABASE_URL ?? `${LOCAL_SERVER}/example_dev`;
-const tests = process.env.TEST_DATABASE_URL ?? `${LOCAL_SERVER}/example_test`;
-
-localPostgres(process.env).prepareDatabases([development, tests]);
+const setup = Effect.gen(function* () {
+	const development = yield* Config.String("DATABASE_URL").pipe(Config.withDefault(`${LOCAL_SERVER}/example_dev`));
+	const tests = yield* Config.String("TEST_DATABASE_URL").pipe(Config.withDefault(`${LOCAL_SERVER}/example_test`));
+	const environment = yield* Config.all({
+		"DOCKER_CONTEXT": Config.String("DOCKER_CONTEXT").pipe(Config.withDefault("")),
+		"DOCKER_HOST": Config.String("DOCKER_HOST").pipe(Config.withDefault("")),
+	});
+	yield* localPostgres(environment).prepareDatabases([development, tests]);
+});
 ```
 
 Generated applications use this configuration-driven approach. An allowlist built from the same URLs adds no restriction; preparation's own local-target check is the guard.
 
-Use `assertLocalDatabase` when the setup script owns a fixed set of database names, as this repository's `script/setup-database.ts` does. Its allowlist restricts configuration to the names the script intends to touch:
+Use `assertLocalDatabase` when the setup script owns a fixed set of database names, as the Platform repository's [`script/setup-database.ts`](https://github.com/ShivaeDev/platform/blob/main/script/setup-database.ts) does. Its allowlist restricts configuration to the names the script intends to touch:
 
 ```ts
+import { Effect } from "effect";
 import { assertLocalDatabase, LOCAL_SERVER, localPostgres } from "@shivaedev/local-postgres/server/localPostgres.ts";
 
-const development = process.env.DATABASE_URL ?? `${LOCAL_SERVER}/example_dev`;
-const tests = process.env.TEST_DATABASE_URL ?? `${LOCAL_SERVER}/example_test`;
-
-assertLocalDatabase(development, ["example_dev"]);
-assertLocalDatabase(tests, ["example_test"]);
-
-const postgres = localPostgres(process.env);
-postgres.prepareDatabases([development, tests]);
+const setup = Effect.gen(function* () {
+	const development = `${LOCAL_SERVER}/example_dev`;
+	const tests = `${LOCAL_SERVER}/example_test`;
+	yield* assertLocalDatabase(development, ["example_dev"]);
+	yield* assertLocalDatabase(tests, ["example_test"]);
+	yield* localPostgres({}).prepareDatabases([development, tests]);
+});
 ```
 
 `assertLocalDatabase` applies the same local-target checks and also rejects a database name outside the caller's allowlist. The fixed names above provide an independent application policy.
 
 ### 2. Once per feature: prepare its schema in application tooling
 
-After `prepareDatabases`, run the application's own schema or migration entry point. This package provides no schema model, migration ledger, fixture catalogue or seed convention. `@shivaedev/effect-sql` owns the SQL and migration APIs.
+After `prepareDatabases`, run the application's own schema or migration entry point. This package provides no schema model, migration ledger, fixture catalogue or seed convention. `@shivaedev/sql` owns the SQL and migration APIs.
 
 ### 3. In daily setup: prepare again and inspect with SQL
 
 ```ts
+import { Effect } from "effect";
 import { LOCAL_SERVER, localPostgres } from "@shivaedev/local-postgres/server/localPostgres.ts";
 
-const database = process.env.DATABASE_URL ?? `${LOCAL_SERVER}/example_dev`;
-
-const postgres = localPostgres(process.env);
-postgres.prepareDatabases([database]);
-console.log(postgres.sql(database, "SHOW server_version"));
+const setup = Effect.gen(function* () {
+	const database = `${LOCAL_SERVER}/example_dev`;
+	const postgres = localPostgres({});
+	yield* postgres.prepareDatabases([database]);
+	yield* Effect.log(yield* postgres.sql(database, "SHOW server_version"));
+});
 ```
 
-The version query returns the string `18.6`. `sql` also accepts a `URL` and returns the command's trimmed text. URLs carrying the application's `schema` and `connection_limit` settings work for this query; those settings are removed before calling PostgreSQL's client.
+Run these setup Effects at a Node entry point with `NodeRuntime.runMain(setup.pipe(Effect.provide(NodeServices.layer)))`, as in the first example. The version query returns `18.6` for the managed image; native distributions may append packaging details. `sql` also accepts a `URL` and returns the command's trimmed text. URLs carrying the application's `schema` and `connection_limit` settings work for this query; those settings are removed before calling PostgreSQL's client.
 
 `startPostgres(connection)` prepares the service without choosing an application database to create. Its connection defaults to `LOCAL_SERVER`. Prefer `prepareDatabases` when the setup script needs named databases as well.
 
-On each start, setup reads `SHOW max_connections`. When the shared container allows fewer than 500 connections, setup applies `ALTER SYSTEM SET max_connections = 500`, restarts that same container, waits for readiness and confirms the setting. Existing data stays in place. A limit of 500 or higher causes no setting change or restart. If the setting cannot be applied, setup throws `PostgresSettingError` from `@shivaedev/local-postgres/server/localConnections.ts`, with `_tag`, `container`, `setting` and the original `cause`.
+On each start, setup reads `SHOW max_connections`. Native servers retain their configured limit. When the running managed container publishes port 55432 and allows fewer than 500 connections, setup applies `ALTER SYSTEM SET max_connections = 500`, restarts that same container, waits for readiness and confirms the setting. Existing data stays in place. A limit of 500 or higher causes no setting change or restart. If the setting cannot be applied, setup fails with `PostgresSettingError` from `@shivaedev/local-postgres/server/localConnections.ts`, with `_tag`, `container`, `setting` and the original `cause`.
 
 ### API
 
 Import the setup API from `@shivaedev/local-postgres/server/localPostgres.ts`:
 
-| Export | Purpose |
-| --- | --- |
-| `LOCAL_SERVER` | The base URL `postgresql://postgres:postgres@127.0.0.1:55432`. Append the application database name. |
-| `assertLocalDatabase(value: string, names: readonly string[]): URL` | Validate a local database URL against application-owned allowed names. |
+| Export                                                                        | Purpose                                                                                                                                                                                                              |
+| ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `LOCAL_SERVER`                                                                | The base URL `postgresql://postgres:postgres@127.0.0.1:55432`. Append the application database name.                                                                                                                 |
+| `assertLocalDatabase(value: string, names: readonly string[])`                | Return an Effect validating a local database URL against application-owned allowed names.                                                                                                                            |
 | `localPostgres(environment: DockerEnvironment, readiness?: ReadinessOptions)` | Create the setup functions using the Docker settings to validate. After starting the container, `startPostgres` checks readiness `attempts` times (default 30), waiting `delayMillis` between checks (default 1000). |
-| `prepareDatabases(values: readonly string[]): void` | Prepare the service and create absent databases. |
-| `startPostgres(connection?: string): void` | Prepare the service; the default connection is `LOCAL_SERVER`. |
-| `sql(value: string \| URL, query: string): string` | Execute SQL through PostgreSQL's command-line client. |
+| `prepareDatabases(values: readonly string[])`                                 | Return an Effect preparing the service and creating absent databases.                                                                                                                                                |
+| `startPostgres(connection?: string)`                                          | Return an Effect preparing the service; the default connection is `LOCAL_SERVER`.                                                                                                                                    |
+| `sql(value: string \| URL, query: string)`                                    | Return an Effect executing SQL through PostgreSQL's command-line client.                                                                                                                                             |
 
-The last three functions are members of the object returned by `localPostgres`, not module-level exports. They throw on failure; they are synchronous Node functions rather than Effects.
+The last three functions are members of the object returned by `localPostgres`, not module-level exports. They fail in the typed error channel. `PostgresCommandError` carries the command, diagnostic message and exit code or platform cause; `LocalPostgresError` describes local-target and image refusals, and malformed URL password escapes. Exhausted readiness checks retain their final failure; a version mismatch always names a version the service returned.
 
 The module export pattern also exposes the lower-level Docker and container command functions in `@shivaedev/local-postgres/server/localDocker.ts` and `@shivaedev/local-postgres/server/localContainer.ts`. Use `@shivaedev/local-postgres/server/localPostgres.ts` for application preparation.
 
 ### Install and machine setup
 
 ```sh
-pnpm add --save-dev @shivaedev/local-postgres
+pnpm add --save-dev @shivaedev/local-postgres @effect/platform-node effect
 ```
 
-The package requires Node 24 or later and has no runtime dependencies. It needs host `psql` or a local Docker installation. SQL uses host `psql` when available and falls back to the container's client when the host executable is missing. Both clients receive the connection password through `PGPASSWORD`, outside the command line. Query failures retain PostgreSQL's diagnostics and the original error as `cause` without exposing the connection password.
+The package requires Node 24 or later and uses Effect as a peer dependency. It needs host `psql` or a local Docker installation. SQL uses host `psql` when available and falls back to the container's client when the host executable is missing. Both clients receive the connection password through `PGPASSWORD`, outside the command line. Query failures retain PostgreSQL's diagnostics and command failure details (and a platform `cause` when a process cannot start) without exposing the connection password.
 
 The shared baseline is PostgreSQL 18.6 on loopback port 55432. Docker preparation uses container and volume name `development-postgres`, loopback publication `127.0.0.1:55432:5432`, and this image:
 
@@ -114,14 +127,14 @@ The shared baseline is PostgreSQL 18.6 on loopback port 55432. Docker preparatio
 postgres:18.6-alpine@sha256:77f585114c32fbca283dc835b0596f4e52b51b4c6662d7810b2f4084f60a1873
 ```
 
-A newly created container uses username and password `postgres`; connection URLs supply credentials for client commands. Setup refuses a running version other than 18.6 with `PostgresVersionMismatch` from `@shivaedev/local-postgres/server/PostgresVersionMismatch.ts`. The error carries `_tag: "PostgresVersionMismatch"`, `expectedVersion` and `observedVersion`. A running PostgreSQL 17 service is refused without losing its existing rows; upgrading it while preserving its data is your job. Container preparation and container-client fallback also check the managed image; a successful host-`psql` version probe does not inspect that image.
+A newly created container uses username and password `postgres`; connection URLs supply credentials for client commands. Setup accepts native PostgreSQL 18.6 version strings with distribution suffixes, such as `18.6 (Debian 18.6-1.pgdg13+2)`, without requiring a managed container or Docker installation. Setup refuses a running release other than 18.6 with `PostgresVersionMismatch` from `@shivaedev/local-postgres/server/PostgresVersionMismatch.ts`. The error carries `_tag: "PostgresVersionMismatch"`, `expectedVersion` and `observedVersion`. A running PostgreSQL 17 service is refused without losing its existing rows; upgrading it while preserving its data is your job. Container preparation and container-client fallback also check the managed image; a successful host-`psql` version probe does not inspect that image.
 
-Pass the process's actual Docker settings to `localPostgres`, as `process.env` in the examples does. With `DOCKER_CONTEXT`, endpoint validation uses that context and ignores `DOCKER_HOST`; otherwise it validates `DOCKER_HOST` or the active context. Remote endpoints are rejected before a Docker operation. Docker subprocesses inherit the process environment. Supplying a different object does not configure those subprocesses.
+Read Docker settings through Effect Config and pass them to `localPostgres`, as in the configuration example. With `DOCKER_CONTEXT`, endpoint validation uses that context and ignores `DOCKER_HOST`; otherwise it validates `DOCKER_HOST` or the active context. Remote endpoints are rejected before a Docker operation. Each operation pins `DOCKER_HOST` to the validated endpoint and clears `DOCKER_CONTEXT`. The lower-level `docker` function refuses command environment settings that conflict with the supplied `DOCKER_HOST` or `DOCKER_CONTEXT` before invoking Docker.
 
 ### Limits
 
 - The service version, port, container name and volume name are fixed. Choose any upgrade and data-preservation procedure outside this package.
-- Commands block the calling thread. Keep them in development and test setup tooling.
+- Keep commands in development and test setup tooling; setup never becomes an application request path.
 - Keep allowed names, schema changes, test isolation and cleanup in the application. Preparation is not a database reset.
 - A prepared database name has 1–63 lowercase letters, digits or underscores and starts with a letter. An allowlisted connection URL does not bypass this SQL-name constraint.
 - Concurrent creation of the same absent database is not supported. Prepare databases before parallel tests begin.

package/dist/server/LocalPostgresError.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const LocalPostgresError_base: Schema.Class<LocalPostgresError, Schema.TaggedStruct<"LocalPostgresError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class LocalPostgresError extends LocalPostgresError_base {
+}
+export {};
+//# sourceMappingURL=LocalPostgresError.d.ts.map

package/dist/server/LocalPostgresError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalPostgresError.d.ts","sourceRoot":"","sources":["../../src/server/LocalPostgresError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;AAEhC,qBAAa,kBAAmB,SAAQ,uBAEtC;CAAG"}

package/dist/server/LocalPostgresError.js

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+export class LocalPostgresError extends Schema.TaggedError()("LocalPostgresError", {
+    message: Schema.String,
+}) {
+}
+//# sourceMappingURL=LocalPostgresError.js.map

package/dist/server/LocalPostgresError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalPostgresError.js","sourceRoot":"","sources":["../../src/server/LocalPostgresError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,OAAO,kBAAmB,SAAQ,MAAM,CAAC,WAAW,EAAsB,CAAC,oBAAoB,EAAE;IACtG,OAAO,EAAE,MAAM,CAAC,MAAM;CACtB,CAAC;CAAG"}

package/dist/server/PostgresCommandError.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+declare const PostgresCommandError_base: Schema.Class<PostgresCommandError, Schema.TaggedStruct<"PostgresCommandError", {
+    readonly cause: Schema.optional<Schema.Unknown>;
+    readonly command: Schema.String;
+    readonly exitCode: Schema.optional<Schema.Number>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PostgresCommandError extends PostgresCommandError_base {
+}
+export {};
+//# sourceMappingURL=PostgresCommandError.d.ts.map

package/dist/server/PostgresCommandError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresCommandError.d.ts","sourceRoot":"","sources":["../../src/server/PostgresCommandError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;;;AAEhC,qBAAa,oBAAqB,SAAQ,yBAKxC;CAAG"}

package/dist/server/PostgresCommandError.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+export class PostgresCommandError extends Schema.TaggedError()("PostgresCommandError", {
+    cause: Schema.optional(Schema.Unknown),
+    command: Schema.String,
+    exitCode: Schema.optional(Schema.Number),
+    message: Schema.String,
+}) {
+}
+//# sourceMappingURL=PostgresCommandError.js.map

package/dist/server/PostgresCommandError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresCommandError.js","sourceRoot":"","sources":["../../src/server/PostgresCommandError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,OAAO,oBAAqB,SAAQ,MAAM,CAAC,WAAW,EAAwB,CAAC,sBAAsB,EAAE;IAC5G,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,MAAM;CACtB,CAAC;CAAG"}

package/dist/server/PostgresVersionMismatch.d.ts

@@ -1,7 +1,10 @@
-export declare class PostgresVersionMismatch extends Error {
-    readonly _tag = "PostgresVersionMismatch";
-    readonly expectedVersion = "18.6";
-    readonly observedVersion: string | undefined;
-    constructor(observedVersion: string | undefined);
+import { Schema } from "effect";
+declare const PostgresVersionMismatch_base: Schema.Class<PostgresVersionMismatch, Schema.TaggedStruct<"PostgresVersionMismatch", {
+    readonly expectedVersion: Schema.Literal<"18.6">;
+    readonly observedVersion: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PostgresVersionMismatch extends PostgresVersionMismatch_base {
+    get message(): string;
 }
+export {};
 //# sourceMappingURL=PostgresVersionMismatch.d.ts.map

package/dist/server/PostgresVersionMismatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PostgresVersionMismatch.d.ts","sourceRoot":"","sources":["../../src/server/PostgresVersionMismatch.ts"],"names":[],"mappings":"AAAA,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,6BAA6B;IAC1C,QAAQ,CAAC,eAAe,UAAU;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7C,YAAY,eAAe,EAAE,MAAM,GAAG,SAAS,EAG9C;CACD"}
+{"version":3,"file":"PostgresVersionMismatch.d.ts","sourceRoot":"","sources":["../../src/server/PostgresVersionMismatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;AAEhC,qBAAa,uBAAwB,SAAQ,4BAG3C;IACD,IAAa,OAAO,WAEnB;CACD"}

package/dist/server/PostgresVersionMismatch.js

@@ -1,10 +1,10 @@
-export class PostgresVersionMismatch extends Error {
-    _tag = "PostgresVersionMismatch";
-    expectedVersion = "18.6";
-    observedVersion;
-    constructor(observedVersion) {
-        super("Expected local PostgreSQL 18.6. Check the existing service; setup never removes containers or data.");
-        this.observedVersion = observedVersion;
+import { Schema } from "effect";
+export class PostgresVersionMismatch extends Schema.TaggedError()("PostgresVersionMismatch", {
+    expectedVersion: Schema.Literal("18.6"),
+    observedVersion: Schema.String,
+}) {
+    get message() {
+        return "Expected local PostgreSQL 18.6. Check the existing service; setup never removes containers or data.";
     }
 }
 //# sourceMappingURL=PostgresVersionMismatch.js.map

package/dist/server/PostgresVersionMismatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"PostgresVersionMismatch.js","sourceRoot":"","sources":["../../src/server/PostgresVersionMismatch.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IACxC,IAAI,GAAG,yBAAyB,CAAC;IACjC,eAAe,GAAG,MAAM,CAAC;IACzB,eAAe,CAAqB;IAE7C,YAAY,eAAmC;QAC9C,KAAK,CAAC,qGAAqG,CAAC,CAAC;QAC7G,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACxC,CAAC;CACD"}
+{"version":3,"file":"PostgresVersionMismatch.js","sourceRoot":"","sources":["../../src/server/PostgresVersionMismatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,OAAO,uBAAwB,SAAQ,MAAM,CAAC,WAAW,EAA2B,CAAC,yBAAyB,EAAE;IACrH,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC,MAAM;CAC9B,CAAC;IACD,IAAa,OAAO;QACnB,OAAO,qGAAqG,CAAC;IAC9G,CAAC;CACD"}

package/dist/server/clientConnection.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { LocalPostgresError } from "#LocalPostgresError.ts";
+import type { CommandOptions } from "#runCommand.ts";
+export declare const clientConnection: (value: URL, options?: CommandOptions | undefined) => Effect.Effect<{
+    options: {
+        env: {
+            PGPASSWORD?: string;
+        };
+        extendEnv: boolean;
+    };
+    url: import("url").URL;
+}, LocalPostgresError, never>;
+//# sourceMappingURL=clientConnection.d.ts.map

package/dist/server/clientConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientConnection.d.ts","sourceRoot":"","sources":["../../src/server/clientConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,gBAAgB;;;;;;;;6BAe3B,CAAC"}

package/dist/server/clientConnection.js

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import { LocalPostgresError } from "#LocalPostgresError.ts";
+export const clientConnection = Effect.fn("LocalPostgres.clientConnection")(function* (value, options = {}) {
+    const url = new URL(value);
+    // libpq treats + literally in URI passwords.
+    const password = yield* Effect.try({
+        catch: () => new LocalPostgresError({ message: "Invalid local database password escape." }),
+        try: () => new URLSearchParams(url.search.replaceAll("+", "%2B")).getAll("password").at(-1) ?? decodeURIComponent(url.password),
+    });
+    url.password = "";
+    for (const key of ["password", "schema", "connection_limit", "pool_timeout", "pgbouncer"]) {
+        url.searchParams.delete(key);
+    }
+    if (!url.searchParams.has("connect_timeout")) {
+        url.searchParams.set("connect_timeout", "3");
+    }
+    return { options: { ...options, env: { ...options.env, ...(password && { "PGPASSWORD": password }) }, extendEnv: true }, url };
+});
+//# sourceMappingURL=clientConnection.js.map

package/dist/server/clientConnection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientConnection.js","sourceRoot":"","sources":["../../src/server/clientConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,EAAE,CAAC,gCAAgC,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAU,EAAE,OAAO,GAAmB,EAAE;IAC9H,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;IAC3B,6CAA6C;IAC7C,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;QAClC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,kBAAkB,CAAC,EAAE,OAAO,EAAE,yCAAyC,EAAE,CAAC;QAC3F,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC;KAC/H,CAAC,CAAC;IACH,GAAG,CAAC,QAAQ,GAAG,EAAE,CAAC;IAClB,KAAK,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,CAAC,EAAE,CAAC;QAC3F,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;QAC9C,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC;AAChI,CAAC,CAAC,CAAC"}

package/dist/server/localConnections.d.ts

@@ -1,8 +1,18 @@
-export declare class PostgresSettingError extends Error {
-    readonly _tag = "PostgresSettingError";
-    readonly container = "development-postgres";
-    readonly setting = "max_connections";
-    constructor(message: string, options: ErrorOptions);
+import { Effect, Schema } from "effect";
+import type { ChildProcessSpawner } from "effect/process";
+import { LocalPostgresError } from "#LocalPostgresError.ts";
+import type { docker as localDocker } from "#localDocker.ts";
+import type { PostgresCommandError } from "#PostgresCommandError.ts";
+import type { PostgresVersionMismatch } from "#PostgresVersionMismatch.ts";
+declare const PostgresSettingError_base: Schema.Class<PostgresSettingError, Schema.TaggedStruct<"PostgresSettingError", {
+    readonly cause: Schema.Unknown;
+    readonly container: Schema.Literal<"development-postgres">;
+    readonly setting: Schema.Literal<"max_connections">;
+}>, import("effect/Cause").YieldableError>;
+export declare class PostgresSettingError extends PostgresSettingError_base {
+    get message(): string;
 }
-export declare function ensureConnections(docker: (args: readonly string[]) => string, sql: (query: string) => string, ready: () => void): void;
+type Query = (query: string) => Effect.Effect<string, LocalPostgresError | PostgresCommandError, ChildProcessSpawner.ChildProcessSpawner>;
+export declare const ensureConnections: (docker: (args: readonly string[]) => ReturnType<typeof localDocker>, sql: Query, ready: () => Effect.Effect<void, LocalPostgresError | PostgresCommandError | PostgresVersionMismatch, ChildProcessSpawner.ChildProcessSpawner>) => Effect.Effect<void, PostgresSettingError, ChildProcessSpawner.ChildProcessSpawner>;
+export {};
 //# sourceMappingURL=localConnections.d.ts.map

package/dist/server/localConnections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localConnections.d.ts","sourceRoot":"","sources":["../../src/server/localConnections.ts"],"names":[],"mappings":"AAEA,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,0BAA0B;IACvC,QAAQ,CAAC,SAAS,0BAA0B;IAC5C,QAAQ,CAAC,OAAO,qBAAqB;IAErC,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAGjD;CACD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,QAqB/H"}
+{"version":3,"file":"localConnections.d.ts","sourceRoot":"","sources":["../../src/server/localConnections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;;;;;;AAE3E,qBAAa,oBAAqB,SAAQ,yBAIxC;IACD,IAAa,OAAO,WAEnB;CACD;AAED,KAAK,KAAK,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,oBAAoB,EAAE,mBAAmB,CAAC,mBAAmB,CAAC,CAAC;AAE1I,eAAO,MAAM,iBAAiB,kBACd,SAAS,MAAM,EAAE,KAAK,UAAU,CAAC,OAAO,WAAW,CAAC,2BAEtD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,uBAAuB,EAAE,mBAAmB,CAAC,mBAAmB,CAAC,uFA6B7I,CAAC"}

package/dist/server/localConnections.js

@@ -1,34 +1,40 @@
-import { POSTGRES_IMAGE } from "./localContainer.js";
-export class PostgresSettingError extends Error {
-    _tag = "PostgresSettingError";
-    container = "development-postgres";
-    setting = "max_connections";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "PostgresSettingError";
+import { Effect, Schema } from "effect";
+import { LocalPostgresError } from "#LocalPostgresError.ts";
+import { POSTGRES_IMAGE } from "#localContainer.ts";
+export class PostgresSettingError extends Schema.TaggedError()("PostgresSettingError", {
+    cause: Schema.Unknown,
+    container: Schema.Literal("development-postgres"),
+    setting: Schema.Literal("max_connections"),
+}) {
+    get message() {
+        return "Could not set max_connections to at least 500 in container development-postgres.";
     }
 }
-export function ensureConnections(docker, sql, ready) {
-    try {
-        const current = Number(sql("SHOW max_connections"));
+export const ensureConnections = Effect.fn("LocalPostgres.ensureConnections")(function* (docker, sql, ready) {
+    yield* Effect.gen(function* () {
+        const current = Number(yield* sql("SHOW max_connections"));
         if (!Number.isInteger(current) || current <= 0) {
-            throw new Error("PostgreSQL returned an invalid max_connections value.");
+            return yield* new LocalPostgresError({ message: "PostgreSQL returned an invalid max_connections value." });
         }
         if (current >= 500) {
             return;
         }
-        if (docker(["inspect", "--format", "{{.Config.Image}}", "development-postgres"]).trim() !== POSTGRES_IMAGE) {
-            throw new Error("The shared PostgreSQL container uses a different image. Preserve its data and upgrade it explicitly.");
+        const managed = yield* docker(["ps", "--filter", "name=^/development-postgres$", "--filter", "publish=55432", "--format", "{{.ID}}"]).pipe(Effect.catchTag("PostgresCommandError", () => Effect.succeed("")));
+        if (!managed) {
+            return;
         }
-        sql("ALTER SYSTEM SET max_connections = 500");
-        docker(["restart", "development-postgres"]);
-        ready();
-        if (!(Number(sql("SHOW max_connections")) >= 500)) {
-            throw new Error("PostgreSQL did not apply max_connections after restarting.");
+        const image = yield* docker(["inspect", "--format", "{{.Config.Image}}", "development-postgres"]);
+        if (image !== POSTGRES_IMAGE) {
+            return yield* new LocalPostgresError({
+                message: "The shared PostgreSQL container uses a different image. Preserve its data and upgrade it explicitly.",
+            });
         }
-    }
-    catch (cause) {
-        throw new PostgresSettingError("Could not set max_connections to at least 500 in container development-postgres.", { cause });
-    }
-}
+        yield* sql("ALTER SYSTEM SET max_connections = 500");
+        yield* docker(["restart", "development-postgres"]);
+        yield* ready();
+        if (!(Number(yield* sql("SHOW max_connections")) >= 500)) {
+            return yield* new LocalPostgresError({ message: "PostgreSQL did not apply max_connections after restarting." });
+        }
+    }).pipe(Effect.mapError((cause) => new PostgresSettingError({ cause, container: "development-postgres", setting: "max_connections" })));
+});
 //# sourceMappingURL=localConnections.js.map

package/dist/server/localConnections.js.map

@@ -1 +1 @@
-{"version":3,"file":"localConnections.js","sourceRoot":"","sources":["../../src/server/localConnections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IACrC,IAAI,GAAG,sBAAsB,CAAC;IAC9B,SAAS,GAAG,sBAAsB,CAAC;IACnC,OAAO,GAAG,iBAAiB,CAAC;IAErC,YAAY,OAAe,EAAE,OAAqB;QACjD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACpC,CAAC;CACD;AAED,MAAM,UAAU,iBAAiB,CAAC,MAA2C,EAAE,GAA8B,EAAE,KAAiB;IAC/H,IAAI,CAAC;QACJ,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC1E,CAAC;QACD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;YACpB,OAAO;QACR,CAAC;QACD,IAAI,MAAM,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,sBAAsB,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,cAAc,EAAE,CAAC;YAC5G,MAAM,IAAI,KAAK,CAAC,sGAAsG,CAAC,CAAC;QACzH,CAAC;QACD,GAAG,CAAC,wCAAwC,CAAC,CAAC;QAC9C,MAAM,CAAC,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC,CAAC;QAC5C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAC/E,CAAC;IACF,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,MAAM,IAAI,oBAAoB,CAAC,kFAAkF,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC/H,CAAC;AACF,CAAC"}
+{"version":3,"file":"localConnections.js","sourceRoot":"","sources":["../../src/server/localConnections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAExC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAKpD,MAAM,OAAO,oBAAqB,SAAQ,MAAM,CAAC,WAAW,EAAwB,CAAC,sBAAsB,EAAE;IAC5G,KAAK,EAAE,MAAM,CAAC,OAAO;IACrB,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,sBAAsB,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC;CAC1C,CAAC;IACD,IAAa,OAAO;QACnB,OAAO,kFAAkF,CAAC;IAC3F,CAAC;CACD;AAID,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,EAAE,CAAC,iCAAiC,CAAC,CAAC,QAAQ,CAAC,EACtF,MAAmE,EACnE,GAAU,EACV,KAA8I;IAE9I,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAC1B,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;YAChD,OAAO,KAAK,CAAC,CAAC,IAAI,kBAAkB,CAAC,EAAE,OAAO,EAAE,uDAAuD,EAAE,CAAC,CAAC;QAC5G,CAAC;QACD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;YACpB,OAAO;QACR,CAAC;QACD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,UAAU,EAAE,8BAA8B,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CACzI,MAAM,CAAC,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CACjE,CAAC;QACF,IAAI,CAAC,OAAO,EAAE,CAAC;YACd,OAAO;QACR,CAAC;QACD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,sBAAsB,CAAC,CAAC,CAAC;QAClG,IAAI,KAAK,KAAK,cAAc,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC,CAAC,IAAI,kBAAkB,CAAC;gBACpC,OAAO,EAAE,sGAAsG;aAC/G,CAAC,CAAC;QACJ,CAAC;QACD,KAAK,CAAC,CAAC,GAAG,CAAC,wCAAwC,CAAC,CAAC;QACrD,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC,CAAC;QACnD,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YAC1D,OAAO,KAAK,CAAC,CAAC,IAAI,kBAAkB,CAAC,EAAE,OAAO,EAAE,4DAA4D,EAAE,CAAC,CAAC;QACjH,CAAC;IACF,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,oBAAoB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,sBAAsB,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC,CAAC,CAAC,CAAC;AACzI,CAAC,CAAC,CAAC"}

package/dist/server/localContainer.d.ts

@@ -1,7 +1,11 @@
-import type { ExecFileSyncOptionsWithStringEncoding } from "node:child_process";
+import { Effect } from "effect";
+import { LocalPostgresError } from "#LocalPostgresError.ts";
+import type { docker as runDocker } from "#localDocker.ts";
+import { PostgresCommandError } from "#PostgresCommandError.ts";
+import type { CommandOptions } from "#runCommand.ts";
 export declare const POSTGRES_IMAGE = "postgres:18.6-alpine@sha256:77f585114c32fbca283dc835b0596f4e52b51b4c6662d7810b2f4084f60a1873";
-type Docker = (args: readonly string[], options?: ExecFileSyncOptionsWithStringEncoding) => string;
-export declare function sqlInContainer(docker: Docker, url: URL, args: readonly string[], options: ExecFileSyncOptionsWithStringEncoding): string;
-export declare function startContainer(docker: Docker): void;
+type Docker = (args: readonly string[], options?: CommandOptions) => ReturnType<typeof runDocker>;
+export declare const sqlInContainer: (docker: Docker, url: URL, args: readonly string[], options: CommandOptions) => Effect.Effect<string, LocalPostgresError | PostgresCommandError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner>;
+export declare const startContainer: (docker: Docker) => Effect.Effect<undefined, LocalPostgresError | PostgresCommandError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner>;
 export {};
 //# sourceMappingURL=localContainer.d.ts.map

package/dist/server/localContainer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localContainer.d.ts","sourceRoot":"","sources":["../../src/server/localContainer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,oBAAoB,CAAC;AAGhF,eAAO,MAAM,cAAc,iGAAiG,CAAC;AAE7H,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,qCAAqC,KAAK,MAAM,CAAC;AAEnG,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,qCAAqC,UAuB/H;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,QA+B5C"}
+{"version":3,"file":"localContainer.d.ts","sourceRoot":"","sources":["../../src/server/localContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,cAAc,iGAAiG,CAAC;AAE7H,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAElG,eAAO,MAAM,cAAc,oNAmBzB,CAAC;AAEH,eAAO,MAAM,cAAc,2JA2BzB,CAAC"}

package/dist/server/localContainer.js

@@ -1,49 +1,37 @@
-import { env } from "node:process";
+import { Effect } from "effect";
+import { clientConnection } from "#clientConnection.ts";
+import { LocalPostgresError } from "#LocalPostgresError.ts";
+import { PostgresCommandError } from "#PostgresCommandError.ts";
 export const POSTGRES_IMAGE = "postgres:18.6-alpine@sha256:77f585114c32fbca283dc835b0596f4e52b51b4c6662d7810b2f4084f60a1873";
 const CONTAINER = "development-postgres";
-export function sqlInContainer(docker, url, args, options) {
-    const id = docker(["ps", "--filter", "publish=55432", "--format", "{{.ID}}"], options).trim();
+export const sqlInContainer = Effect.fn("LocalPostgres.sqlInContainer")(function* (docker, url, args, options) {
+    const id = yield* docker(["ps", "--filter", "publish=55432", "--format", "{{.ID}}"], options);
     if (!id || id.includes("\n")) {
-        throw new Error("Install psql or start the shared PostgreSQL service with Docker.");
+        return yield* new PostgresCommandError({ command: "psql", message: "Install psql or start the shared PostgreSQL service with Docker." });
     }
-    if (docker(["inspect", "--format", "{{.Config.Image}}", id], options).trim() !== POSTGRES_IMAGE) {
-        throw new Error("The shared PostgreSQL image differs from the pinned baseline. Upgrade explicitly, preserving data.");
+    if ((yield* docker(["inspect", "--format", "{{.Config.Image}}", id], options)) !== POSTGRES_IMAGE) {
+        return yield* new LocalPostgresError({
+            message: "The shared PostgreSQL image differs from the pinned baseline. Upgrade explicitly, preserving data.",
+        });
     }
-    // libpq treats + literally in URI passwords.
-    const password = new URLSearchParams(url.search.replaceAll("+", "%2B")).getAll("password").at(-1) ?? decodeURIComponent(url.password);
-    const inside = new URL(url);
+    const { url: inside, options: settings } = yield* clientConnection(url, options);
     inside.hostname = "127.0.0.1";
     inside.port = "5432";
-    inside.password = "";
-    inside.searchParams.delete("password");
-    try {
-        return docker(["exec", "--env", "PGPASSWORD", id, "psql", ...args, "--dbname", inside.toString()], {
-            ...options,
-            env: { ...env, ...options.env, ...(password && { "PGPASSWORD": password }) },
-        }).trim();
-    }
-    catch (error) {
-        throw new Error(error instanceof Error && "stderr" in error ? String(error.stderr) : "PostgreSQL query failed.", { cause: error });
-    }
-}
-export function startContainer(docker) {
-    docker(["info"]);
-    let existing;
-    try {
-        docker(["container", "inspect", CONTAINER]);
-        existing = true;
-    }
-    catch {
-        existing = false;
-    }
+    return yield* docker(["exec", "--env", "PGPASSWORD", id, "psql", ...args, "--dbname", inside.toString()], settings);
+});
+export const startContainer = Effect.fn("LocalPostgres.startContainer")(function* (docker) {
+    yield* docker(["info"]);
+    const existing = yield* docker(["container", "ls", "--all", "--filter", `name=^/${CONTAINER}$`, "--format", "{{.ID}}"]);
     if (existing) {
-        if (docker(["inspect", "--format", "{{.Config.Image}}", CONTAINER]).trim() !== POSTGRES_IMAGE) {
-            throw new Error("The shared PostgreSQL container uses a different image. Preserve its volume and upgrade it explicitly.");
+        if ((yield* docker(["inspect", "--format", "{{.Config.Image}}", CONTAINER])) !== POSTGRES_IMAGE) {
+            return yield* new LocalPostgresError({
+                message: "The shared PostgreSQL container uses a different image. Preserve its volume and upgrade it explicitly.",
+            });
         }
-        docker(["start", CONTAINER]);
+        yield* docker(["start", CONTAINER]);
     }
     else {
-        docker([
+        yield* docker([
             "run",
             "--detach",
             "--name",
@@ -59,5 +47,5 @@ export function startContainer(docker) {
             POSTGRES_IMAGE,
         ]);
     }
-}
+});
 //# sourceMappingURL=localContainer.js.map