effect-vercel 0.4.0 → 0.6.0

package/README.md

@@ -11,7 +11,9 @@ import * as AiGateway from "effect-vercel/AiGateway"
 | ------------------------------------ | ------------------------------------------------------------------------------- |
 | `effect-vercel/AiGateway`            | [Vercel AI Gateway](https://vercel.com/docs/ai-gateway) for Effect AI           |
 | `effect-vercel/AiGatewayCredentials` | How AI Gateway requests authenticate                                            |
+| `effect-vercel/Functions`            | Bindings for `@vercel/functions`: `waitUntil`                                   |
 | `effect-vercel/Oidc`                 | The OIDC token Vercel issues to a deployment                                    |
+| `effect-vercel/PgClient`             | `@effect/sql-pg` pool that doesn't leave connections open on frozen instances   |
 | `effect-vercel/RuntimeCache`         | [Runtime Cache](https://vercel.com/docs/runtime-cache) for Effect `Persistence` |
 
 ## Install
@@ -19,7 +21,8 @@ import * as AiGateway from "effect-vercel/AiGateway"
 ```sh
 pnpm add effect-vercel effect
 pnpm add @effect/ai-anthropic   # only for effect-vercel/AiGateway
-pnpm add @vercel/functions      # only for effect-vercel/RuntimeCache
+pnpm add @vercel/functions      # only for effect-vercel/Functions and RuntimeCache
+pnpm add @effect/sql-pg         # only for effect-vercel/PgClient
 ```
 
 ## AI Gateway
@@ -120,6 +123,63 @@ unset. It fails with an `OidcError` when neither is set.
 It reads the token on every run, since it rotates per request. It does not refresh an
 expired local token; re-run `vercel env pull`.
 
+## Functions
+
+`Functions.waitUntil(fiber)` keeps the Function running until `fiber` ends, as `waitUntil`
+from `@vercel/functions` does for a promise. Use it to finish work after the response is sent.
+
+```ts
+import * as Functions from "effect-vercel/Functions"
+import { Effect } from "effect"
+
+const handler = Effect.gen(function* () {
+  yield* Effect.forkDetach(sendReceipt).pipe(Effect.tap(Functions.waitUntil))
+  return new Response("OK")
+})
+```
+
+- Fork with `Effect.forkDetach`, or into a scope that outlives the request. A child fiber is
+  interrupted when the request fiber ends, whatever `waitUntil` says.
+- The fiber keeps the request's services. Acquire resources it needs inside its own
+  `Effect.scoped`, since the request's resources may be released first.
+- Failures are not reported. Handle or log them in the forked effect.
+- Vercel stops the work when the Function reaches its maximum duration.
+- Off Vercel, `waitUntil` does nothing and the fiber runs in the background.
+
+## Postgres
+
+`PgClient.layer` is `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+until the pool has closed its connections.
+
+Vercel freezes an instance once no request or `waitUntil` promise is left. A frozen instance
+keeps its sockets open, so a pooler like PgBouncer still counts them against `max_client_conn`.
+During a deploy many instances freeze at once, which can use up the limit. `attachDatabasePool`
+from `@vercel/functions` handles this for node-postgres pools by waiting out the idle timeout
+after each release. It doesn't support the Effect pool, which also closes an idle connection up
+to twice its `idleTimeout` after its last use.
+
+```ts
+import * as PgClient from "effect-vercel/PgClient"
+import { Redacted } from "effect"
+
+const SqlLive = PgClient.layer({
+  url: Redacted.make(process.env.DATABASE_URL!),
+  maxConnections: 3,
+  idleTimeout: "5 seconds",
+})
+```
+
+- It takes the same config as `@effect/sql-pg`, except `stream`: it opens each socket itself
+  and counts it until it closes. While a socket is open, one `waitUntil` promise keeps the
+  instance up.
+- Each time a request takes a connection from the pool, the promise moves to that request, so a
+  busy instance never keeps a finished request open. The wait also ends a second before the
+  request's deadline.
+- It moves the promise from `onAcquire`. An `onAcquire` in your config still runs, after.
+- Keep `idleTimeout` short. The instance stays up until the pool closes its last idle
+  connection.
+- Off Vercel, it behaves like the plain layer.
+
 ## Runtime Cache
 
 `RuntimeCache.layer` provides Effect's `Persistence`, stored in the Vercel Runtime Cache.

package/dist/Functions.d.ts

@@ -0,0 +1,14 @@
+import { Effect, Fiber } from "effect";
+//#region src/Functions.d.ts
+/**
+ * Keeps the Function running until `fiber` ends, as `waitUntil` from
+ * `@vercel/functions` does for a promise. Off Vercel it does nothing.
+ *
+ * The fiber must outlive the request fiber, so fork it with
+ * `Effect.forkDetach` or into a scope that outlives the request. A child
+ * fiber is interrupted when the request fiber ends. Failures are not
+ * reported, so handle them in the forked effect.
+ */
+export declare const waitUntil: <A, E>(fiber: Fiber.Fiber<A, E>) => Effect.Effect<void>;
+//#endregion
+//# sourceMappingURL=Functions.d.ts.map

package/dist/Functions.js

@@ -0,0 +1,34 @@
+import { Effect } from "effect";
+import { waitUntil as waitUntil$1 } from "@vercel/functions";
+//#region src/Functions.ts
+/**
+* Effect bindings for `@vercel/functions`.
+*
+* `waitUntil` keeps the Function running until a fiber ends, so work forked
+* during a request can finish after the response is sent.
+*
+* @example
+* ```ts
+* import * as Functions from "effect-vercel/Functions"
+* import { Effect } from "effect"
+*
+* const handler = Effect.gen(function* () {
+*   yield* Effect.forkDetach(sendReceipt).pipe(Effect.tap(Functions.waitUntil))
+*   return new Response("OK")
+* })
+* ```
+*/
+/**
+* Keeps the Function running until `fiber` ends, as `waitUntil` from
+* `@vercel/functions` does for a promise. Off Vercel it does nothing.
+*
+* The fiber must outlive the request fiber, so fork it with
+* `Effect.forkDetach` or into a scope that outlives the request. A child
+* fiber is interrupted when the request fiber ends. Failures are not
+* reported, so handle them in the forked effect.
+*/
+const waitUntil = (fiber) => Effect.sync(() => waitUntil$1(new Promise((resolve) => fiber.addObserver(() => resolve()))));
+//#endregion
+export { waitUntil };
+
+//# sourceMappingURL=Functions.js.map

package/dist/Functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Functions.js","names":["vercelWaitUntil"],"sources":["../src/Functions.ts"],"sourcesContent":["/**\n * Effect bindings for `@vercel/functions`.\n *\n * `waitUntil` keeps the Function running until a fiber ends, so work forked\n * during a request can finish after the response is sent.\n *\n * @example\n * ```ts\n * import * as Functions from \"effect-vercel/Functions\"\n * import { Effect } from \"effect\"\n *\n * const handler = Effect.gen(function* () {\n *   yield* Effect.forkDetach(sendReceipt).pipe(Effect.tap(Functions.waitUntil))\n *   return new Response(\"OK\")\n * })\n * ```\n */\n\nimport { waitUntil as vercelWaitUntil } from \"@vercel/functions\"\nimport { Effect, type Fiber } from \"effect\"\n\n/**\n * Keeps the Function running until `fiber` ends, as `waitUntil` from\n * `@vercel/functions` does for a promise. Off Vercel it does nothing.\n *\n * The fiber must outlive the request fiber, so fork it with\n * `Effect.forkDetach` or into a scope that outlives the request. A child\n * fiber is interrupted when the request fiber ends. Failures are not\n * reported, so handle them in the forked effect.\n */\nexport const waitUntil = <A, E>(fiber: Fiber.Fiber<A, E>): Effect.Effect<void> =>\n  Effect.sync(() =>\n    vercelWaitUntil(new Promise<void>((resolve) => fiber.addObserver(() => resolve()))),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,aAAmB,UAC9B,OAAO,WACLA,YAAgB,IAAI,SAAe,YAAY,MAAM,kBAAkB,QAAQ,CAAC,CAAC,CAAC,CACpF"}

package/dist/PgClient.d.ts

@@ -0,0 +1,17 @@
+import { Layer } from "effect";
+import { PgClient } from "@effect/sql-pg";
+//#region src/PgClient.d.ts
+/** `PgClient.PgPoolConfig` without `stream`, which this module sets. */
+export type Config<R = never> = Omit<PgClient.PgPoolConfig<R>, "stream">;
+/**
+ * `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+ * until the pool has closed every connection, or the request's deadline
+ * comes. Off Vercel it behaves like the plain layer.
+ *
+ * It opens each socket itself, through the `stream` option, and moves the
+ * wait to the request that takes each connection, through `onAcquire`. An
+ * `onAcquire` in `config` still runs, after that.
+ */
+export declare const layer: <R = never>(config: Config<R>) => Layer.Layer<PgClient.PgClient | import("effect/sql/SqlClient").SqlClient, import("effect/sql/SqlError").SqlError, Exclude<R, import("effect/Scope").Scope | import("effect/reactivity/Reactivity").Reactivity>>;
+//#endregion
+//# sourceMappingURL=PgClient.d.ts.map

package/dist/PgClient.js

@@ -0,0 +1,119 @@
+import { Duration, Effect, Layer, Redacted } from "effect";
+import * as Net from "node:net";
+import { PgClient } from "@effect/sql-pg";
+import { constVoid } from "effect/Function";
+//#region src/PgClient.ts
+/**
+* `@effect/sql-pg` for Vercel Functions: a pool that keeps the instance up
+* while it has a connection open.
+*
+* Vercel freezes an instance once no request or `waitUntil` promise is left.
+* A frozen instance keeps its sockets, so a pooler like PgBouncer keeps
+* counting them as clients until the instance wakes up or dies. With many
+* instances, as during a deploy, they fill up `max_client_conn`.
+* `attachDatabasePool` from `@vercel/functions` waits out the idle timeout
+* after each release, but it only supports node-postgres-like pools, and the
+* Effect pool closes idle connections up to twice its `idleTimeout` after
+* their last use. So this layer counts the pool's sockets and waits until
+* the last one closes.
+*
+* @example
+* ```ts
+* import * as PgClient from "effect-vercel/PgClient"
+* import { Redacted } from "effect"
+*
+* const SqlLive = PgClient.layer({
+*   url: Redacted.make(process.env.DATABASE_URL!),
+*   idleTimeout: "5 seconds",
+* })
+* ```
+*/
+/**
+* Vercel exposes the current request's context on a well-known global symbol.
+* `@vercel/functions` reads `waitUntil` and the deadline from there. Off
+* Vercel, or outside a request, there is no `waitUntil`.
+*/
+const REQUEST_CONTEXT = Symbol.for("@vercel/request-context");
+const currentRequest = () => {
+	return globalThis[REQUEST_CONTEXT]?.get?.();
+};
+/**
+* Keeps the instance up while a tracked socket is open. One `waitUntil`
+* promise holds it, and `follow` moves it to the request running now, as
+* `attachDatabasePool` does, so a busy instance never holds a finished
+* request open. The wait also ends a second before the request's deadline.
+* Outside a request, `follow` keeps the wait where it is.
+*/
+const makeKeepAlive = () => {
+	let open = 0;
+	let release = constVoid;
+	const follow = () => {
+		const request = currentRequest();
+		if (open === 0 || request?.waitUntil === void 0) return;
+		release();
+		const cutoff = Date.parse(request.deadline ?? "") - 1e3;
+		request.waitUntil(new Promise((resolve) => {
+			const timer = Number.isNaN(cutoff) ? void 0 : setTimeout(resolve, cutoff - Date.now());
+			release = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+		}));
+	};
+	const track = (socket) => {
+		open++;
+		follow();
+		socket.once("close", () => {
+			if (--open === 0) release();
+		});
+		return socket;
+	};
+	return {
+		follow,
+		track
+	};
+};
+/**
+* Opens the TCP or Unix socket `@effect/sql-pg` would open for `config`.
+* It still runs TLS and the startup on it.
+*/
+const connect = (config) => {
+	const url = config.url && new URL(Redacted.value(config.url));
+	const param = (name) => url?.searchParams.getAll(name).at(-1);
+	const urlHost = url?.hostname && decodeURIComponent(url.hostname.replace(/^\[(.*)\]$/, "$1"));
+	const host = config.host ?? param("host") ?? (urlHost || "localhost");
+	const port = config.port ?? Number(param("port") ?? (url?.port || 5432));
+	const path = config.path ?? (host.startsWith("/") ? `${host}/.s.PGSQL.${port}` : void 0);
+	if (path !== void 0) return Net.connect({ path });
+	return Net.connect({
+		host,
+		port,
+		noDelay: true,
+		...config.keepAlive !== void 0 && {
+			keepAlive: true,
+			keepAliveInitialDelay: Duration.toMillis(Duration.fromInputUnsafe(config.keepAlive))
+		}
+	});
+};
+/**
+* `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+* until the pool has closed every connection, or the request's deadline
+* comes. Off Vercel it behaves like the plain layer.
+*
+* It opens each socket itself, through the `stream` option, and moves the
+* wait to the request that takes each connection, through `onAcquire`. An
+* `onAcquire` in `config` still runs, after that.
+*/
+const layer = (config) => Layer.suspend(() => {
+	const keepAlive = makeKeepAlive();
+	const follow = Effect.sync(keepAlive.follow);
+	return PgClient.layer({
+		...config,
+		stream: () => keepAlive.track(connect(config)),
+		onAcquire: config.onAcquire ? Effect.andThen(follow, config.onAcquire) : follow
+	});
+});
+//#endregion
+export { layer };
+
+//# sourceMappingURL=PgClient.js.map

package/dist/PgClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PgClient.js","names":["holder"],"sources":["../src/PgClient.ts"],"sourcesContent":["/**\n * `@effect/sql-pg` for Vercel Functions: a pool that keeps the instance up\n * while it has a connection open.\n *\n * Vercel freezes an instance once no request or `waitUntil` promise is left.\n * A frozen instance keeps its sockets, so a pooler like PgBouncer keeps\n * counting them as clients until the instance wakes up or dies. With many\n * instances, as during a deploy, they fill up `max_client_conn`.\n * `attachDatabasePool` from `@vercel/functions` waits out the idle timeout\n * after each release, but it only supports node-postgres-like pools, and the\n * Effect pool closes idle connections up to twice its `idleTimeout` after\n * their last use. So this layer counts the pool's sockets and waits until\n * the last one closes.\n *\n * @example\n * ```ts\n * import * as PgClient from \"effect-vercel/PgClient\"\n * import { Redacted } from \"effect\"\n *\n * const SqlLive = PgClient.layer({\n *   url: Redacted.make(process.env.DATABASE_URL!),\n *   idleTimeout: \"5 seconds\",\n * })\n * ```\n */\n\nimport * as Net from \"node:net\"\nimport { PgClient } from \"@effect/sql-pg\"\nimport { Duration, Effect, Layer, Redacted } from \"effect\"\nimport { constVoid } from \"effect/Function\"\n\n/**\n * Vercel exposes the current request's context on a well-known global symbol.\n * `@vercel/functions` reads `waitUntil` and the deadline from there. Off\n * Vercel, or outside a request, there is no `waitUntil`.\n */\nconst REQUEST_CONTEXT = Symbol.for(\"@vercel/request-context\")\n\ntype RequestContext = {\n  readonly waitUntil?: (promise: Promise<unknown>) => void\n  readonly deadline?: string\n}\n\nconst currentRequest = (): RequestContext | undefined => {\n  const holder = globalThis as typeof globalThis & {\n    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }\n  }\n  return holder[REQUEST_CONTEXT]?.get?.()\n}\n\n/**\n * Keeps the instance up while a tracked socket is open. One `waitUntil`\n * promise holds it, and `follow` moves it to the request running now, as\n * `attachDatabasePool` does, so a busy instance never holds a finished\n * request open. The wait also ends a second before the request's deadline.\n * Outside a request, `follow` keeps the wait where it is.\n */\nconst makeKeepAlive = () => {\n  let open = 0\n  let release = constVoid\n\n  const follow = () => {\n    const request = currentRequest()\n    if (open === 0 || request?.waitUntil === undefined) return\n    release()\n    const cutoff = Date.parse(request.deadline ?? \"\") - 1_000\n    request.waitUntil(\n      new Promise<void>((resolve) => {\n        const timer = Number.isNaN(cutoff) ? undefined : setTimeout(resolve, cutoff - Date.now())\n        release = () => {\n          clearTimeout(timer)\n          resolve()\n        }\n      }),\n    )\n  }\n\n  const track = (socket: Net.Socket) => {\n    open++\n    follow()\n    socket.once(\"close\", () => {\n      if (--open === 0) release()\n    })\n    return socket\n  }\n\n  return { follow, track }\n}\n\n/** `PgClient.PgPoolConfig` without `stream`, which this module sets. */\nexport type Config<R = never> = Omit<PgClient.PgPoolConfig<R>, \"stream\">\n\n/**\n * Opens the TCP or Unix socket `@effect/sql-pg` would open for `config`.\n * It still runs TLS and the startup on it.\n */\nconst connect = (config: Config<unknown>): Net.Socket => {\n  const url = config.url && new URL(Redacted.value(config.url))\n  const param = (name: string) => url?.searchParams.getAll(name).at(-1)\n  const urlHost = url?.hostname && decodeURIComponent(url.hostname.replace(/^\\[(.*)\\]$/, \"$1\"))\n  const host = config.host ?? param(\"host\") ?? (urlHost || \"localhost\")\n  const port = config.port ?? Number(param(\"port\") ?? (url?.port || 5432))\n  const path = config.path ?? (host.startsWith(\"/\") ? `${host}/.s.PGSQL.${port}` : undefined)\n  if (path !== undefined) return Net.connect({ path })\n  return Net.connect({\n    host,\n    port,\n    noDelay: true,\n    ...(config.keepAlive !== undefined && {\n      keepAlive: true,\n      keepAliveInitialDelay: Duration.toMillis(Duration.fromInputUnsafe(config.keepAlive)),\n    }),\n  })\n}\n\n/**\n * `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up\n * until the pool has closed every connection, or the request's deadline\n * comes. Off Vercel it behaves like the plain layer.\n *\n * It opens each socket itself, through the `stream` option, and moves the\n * wait to the request that takes each connection, through `onAcquire`. An\n * `onAcquire` in `config` still runs, after that.\n */\nexport const layer = <R = never>(config: Config<R>) =>\n  Layer.suspend(() => {\n    const keepAlive = makeKeepAlive()\n    const follow = Effect.sync(keepAlive.follow)\n    return PgClient.layer({\n      ...config,\n      stream: () => keepAlive.track(connect(config)),\n      onAcquire: config.onAcquire ? Effect.andThen(follow, config.onAcquire) : follow,\n    })\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAM,kBAAkB,OAAO,IAAI,yBAAyB;AAO5D,MAAM,uBAAmD;CAIvD,OAAOA,WAAO,gBAAgB,EAAE,MAAM;AACxC;;;;;;;;AASA,MAAM,sBAAsB;CAC1B,IAAI,OAAO;CACX,IAAI,UAAU;CAEd,MAAM,eAAe;EACnB,MAAM,UAAU,eAAe;EAC/B,IAAI,SAAS,KAAK,SAAS,cAAc,KAAA,GAAW;EACpD,QAAQ;EACR,MAAM,SAAS,KAAK,MAAM,QAAQ,YAAY,EAAE,IAAI;EACpD,QAAQ,UACN,IAAI,SAAe,YAAY;GAC7B,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI,KAAA,IAAY,WAAW,SAAS,SAAS,KAAK,IAAI,CAAC;GACxF,gBAAgB;IACd,aAAa,KAAK;IAClB,QAAQ;GACV;EACF,CAAC,CACH;CACF;CAEA,MAAM,SAAS,WAAuB;EACpC;EACA,OAAO;EACP,OAAO,KAAK,eAAe;GACzB,IAAI,EAAE,SAAS,GAAG,QAAQ;EAC5B,CAAC;EACD,OAAO;CACT;CAEA,OAAO;EAAE;EAAQ;CAAM;AACzB;;;;;AASA,MAAM,WAAW,WAAwC;CACvD,MAAM,MAAM,OAAO,OAAO,IAAI,IAAI,SAAS,MAAM,OAAO,GAAG,CAAC;CAC5D,MAAM,SAAS,SAAiB,KAAK,aAAa,OAAO,IAAI,CAAC,CAAC,GAAG,EAAE;CACpE,MAAM,UAAU,KAAK,YAAY,mBAAmB,IAAI,SAAS,QAAQ,cAAc,IAAI,CAAC;CAC5F,MAAM,OAAO,OAAO,QAAQ,MAAM,MAAM,MAAM,WAAW;CACzD,MAAM,OAAO,OAAO,QAAQ,OAAO,MAAM,MAAM,MAAM,KAAK,QAAQ,KAAK;CACvE,MAAM,OAAO,OAAO,SAAS,KAAK,WAAW,GAAG,IAAI,GAAG,KAAK,YAAY,SAAS,KAAA;CACjF,IAAI,SAAS,KAAA,GAAW,OAAO,IAAI,QAAQ,EAAE,KAAK,CAAC;CACnD,OAAO,IAAI,QAAQ;EACjB;EACA;EACA,SAAS;EACT,GAAI,OAAO,cAAc,KAAA,KAAa;GACpC,WAAW;GACX,uBAAuB,SAAS,SAAS,SAAS,gBAAgB,OAAO,SAAS,CAAC;EACrF;CACF,CAAC;AACH;;;;;;;;;;AAWA,MAAa,SAAoB,WAC/B,MAAM,cAAc;CAClB,MAAM,YAAY,cAAc;CAChC,MAAM,SAAS,OAAO,KAAK,UAAU,MAAM;CAC3C,OAAO,SAAS,MAAM;EACpB,GAAG;EACH,cAAc,UAAU,MAAM,QAAQ,MAAM,CAAC;EAC7C,WAAW,OAAO,YAAY,OAAO,QAAQ,QAAQ,OAAO,SAAS,IAAI;CAC3E,CAAC;AACH,CAAC"}

package/dist/RuntimeCache.js

@@ -1,6 +1,6 @@
 import { Duration, Effect, Layer } from "effect";
-import { createHash } from "node:crypto";
 import { getCache } from "@vercel/functions";
+import { createHash } from "node:crypto";
 import { Persistence } from "effect/persistence";
 //#region src/RuntimeCache.ts
 /**

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "effect-vercel",
-  "version": "0.4.0",
-  "description": "Effect integrations for Vercel: AI Gateway, OIDC, Runtime Cache",
+  "version": "0.6.0",
+  "description": "Effect integrations for Vercel: AI Gateway, OIDC, Postgres pools, Runtime Cache, waitUntil",
   "keywords": [
     "ai-gateway",
     "effect",
     "effect-ai",
     "oidc",
+    "postgres",
     "runtime-cache",
-    "vercel"
+    "vercel",
+    "wait-until"
   ],
   "homepage": "https://github.com/duailibe/effect-vercel#readme",
   "bugs": {
@@ -29,7 +31,9 @@
   "exports": {
     "./AiGateway": "./dist/AiGateway.js",
     "./AiGatewayCredentials": "./dist/AiGatewayCredentials.js",
+    "./Functions": "./dist/Functions.js",
     "./Oidc": "./dist/Oidc.js",
+    "./PgClient": "./dist/PgClient.js",
     "./RuntimeCache": "./dist/RuntimeCache.js",
     "./package.json": "./package.json"
   },
@@ -48,10 +52,11 @@
   "devDependencies": {
     "@effect/ai-anthropic": "^4.0.0",
     "@effect/language-service": "^0.87.3",
+    "@effect/sql-pg": "^4.0.6",
     "@effect/vitest": "^4.0.0",
     "@types/node": "^24",
     "@vercel/functions": "^3.9.9",
-    "effect": "^4.0.0",
+    "effect": "^4.0.6",
     "oxfmt": "^0.68.0",
     "oxlint": "^1.83.0",
     "tsdown": "^0.23.0",
@@ -60,6 +65,7 @@
   },
   "peerDependencies": {
     "@effect/ai-anthropic": "^4.0.0",
+    "@effect/sql-pg": "^4.0.6",
     "@vercel/functions": "^3.9.9",
     "effect": "^4.0.0"
   },
@@ -67,6 +73,9 @@
     "@effect/ai-anthropic": {
       "optional": true
     },
+    "@effect/sql-pg": {
+      "optional": true
+    },
     "@vercel/functions": {
       "optional": true
     }

package/src/Functions.ts

@@ -0,0 +1,34 @@
+/**
+ * Effect bindings for `@vercel/functions`.
+ *
+ * `waitUntil` keeps the Function running until a fiber ends, so work forked
+ * during a request can finish after the response is sent.
+ *
+ * @example
+ * ```ts
+ * import * as Functions from "effect-vercel/Functions"
+ * import { Effect } from "effect"
+ *
+ * const handler = Effect.gen(function* () {
+ *   yield* Effect.forkDetach(sendReceipt).pipe(Effect.tap(Functions.waitUntil))
+ *   return new Response("OK")
+ * })
+ * ```
+ */
+
+import { waitUntil as vercelWaitUntil } from "@vercel/functions"
+import { Effect, type Fiber } from "effect"
+
+/**
+ * Keeps the Function running until `fiber` ends, as `waitUntil` from
+ * `@vercel/functions` does for a promise. Off Vercel it does nothing.
+ *
+ * The fiber must outlive the request fiber, so fork it with
+ * `Effect.forkDetach` or into a scope that outlives the request. A child
+ * fiber is interrupted when the request fiber ends. Failures are not
+ * reported, so handle them in the forked effect.
+ */
+export const waitUntil = <A, E>(fiber: Fiber.Fiber<A, E>): Effect.Effect<void> =>
+  Effect.sync(() =>
+    vercelWaitUntil(new Promise<void>((resolve) => fiber.addObserver(() => resolve()))),
+  )

package/src/PgClient.ts

@@ -0,0 +1,134 @@
+/**
+ * `@effect/sql-pg` for Vercel Functions: a pool that keeps the instance up
+ * while it has a connection open.
+ *
+ * Vercel freezes an instance once no request or `waitUntil` promise is left.
+ * A frozen instance keeps its sockets, so a pooler like PgBouncer keeps
+ * counting them as clients until the instance wakes up or dies. With many
+ * instances, as during a deploy, they fill up `max_client_conn`.
+ * `attachDatabasePool` from `@vercel/functions` waits out the idle timeout
+ * after each release, but it only supports node-postgres-like pools, and the
+ * Effect pool closes idle connections up to twice its `idleTimeout` after
+ * their last use. So this layer counts the pool's sockets and waits until
+ * the last one closes.
+ *
+ * @example
+ * ```ts
+ * import * as PgClient from "effect-vercel/PgClient"
+ * import { Redacted } from "effect"
+ *
+ * const SqlLive = PgClient.layer({
+ *   url: Redacted.make(process.env.DATABASE_URL!),
+ *   idleTimeout: "5 seconds",
+ * })
+ * ```
+ */
+
+import * as Net from "node:net"
+import { PgClient } from "@effect/sql-pg"
+import { Duration, Effect, Layer, Redacted } from "effect"
+import { constVoid } from "effect/Function"
+
+/**
+ * Vercel exposes the current request's context on a well-known global symbol.
+ * `@vercel/functions` reads `waitUntil` and the deadline from there. Off
+ * Vercel, or outside a request, there is no `waitUntil`.
+ */
+const REQUEST_CONTEXT = Symbol.for("@vercel/request-context")
+
+type RequestContext = {
+  readonly waitUntil?: (promise: Promise<unknown>) => void
+  readonly deadline?: string
+}
+
+const currentRequest = (): RequestContext | undefined => {
+  const holder = globalThis as typeof globalThis & {
+    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }
+  }
+  return holder[REQUEST_CONTEXT]?.get?.()
+}
+
+/**
+ * Keeps the instance up while a tracked socket is open. One `waitUntil`
+ * promise holds it, and `follow` moves it to the request running now, as
+ * `attachDatabasePool` does, so a busy instance never holds a finished
+ * request open. The wait also ends a second before the request's deadline.
+ * Outside a request, `follow` keeps the wait where it is.
+ */
+const makeKeepAlive = () => {
+  let open = 0
+  let release = constVoid
+
+  const follow = () => {
+    const request = currentRequest()
+    if (open === 0 || request?.waitUntil === undefined) return
+    release()
+    const cutoff = Date.parse(request.deadline ?? "") - 1_000
+    request.waitUntil(
+      new Promise<void>((resolve) => {
+        const timer = Number.isNaN(cutoff) ? undefined : setTimeout(resolve, cutoff - Date.now())
+        release = () => {
+          clearTimeout(timer)
+          resolve()
+        }
+      }),
+    )
+  }
+
+  const track = (socket: Net.Socket) => {
+    open++
+    follow()
+    socket.once("close", () => {
+      if (--open === 0) release()
+    })
+    return socket
+  }
+
+  return { follow, track }
+}
+
+/** `PgClient.PgPoolConfig` without `stream`, which this module sets. */
+export type Config<R = never> = Omit<PgClient.PgPoolConfig<R>, "stream">
+
+/**
+ * Opens the TCP or Unix socket `@effect/sql-pg` would open for `config`.
+ * It still runs TLS and the startup on it.
+ */
+const connect = (config: Config<unknown>): Net.Socket => {
+  const url = config.url && new URL(Redacted.value(config.url))
+  const param = (name: string) => url?.searchParams.getAll(name).at(-1)
+  const urlHost = url?.hostname && decodeURIComponent(url.hostname.replace(/^\[(.*)\]$/, "$1"))
+  const host = config.host ?? param("host") ?? (urlHost || "localhost")
+  const port = config.port ?? Number(param("port") ?? (url?.port || 5432))
+  const path = config.path ?? (host.startsWith("/") ? `${host}/.s.PGSQL.${port}` : undefined)
+  if (path !== undefined) return Net.connect({ path })
+  return Net.connect({
+    host,
+    port,
+    noDelay: true,
+    ...(config.keepAlive !== undefined && {
+      keepAlive: true,
+      keepAliveInitialDelay: Duration.toMillis(Duration.fromInputUnsafe(config.keepAlive)),
+    }),
+  })
+}
+
+/**
+ * `PgClient.layer` from `@effect/sql-pg` that keeps the Function instance up
+ * until the pool has closed every connection, or the request's deadline
+ * comes. Off Vercel it behaves like the plain layer.
+ *
+ * It opens each socket itself, through the `stream` option, and moves the
+ * wait to the request that takes each connection, through `onAcquire`. An
+ * `onAcquire` in `config` still runs, after that.
+ */
+export const layer = <R = never>(config: Config<R>) =>
+  Layer.suspend(() => {
+    const keepAlive = makeKeepAlive()
+    const follow = Effect.sync(keepAlive.follow)
+    return PgClient.layer({
+      ...config,
+      stream: () => keepAlive.track(connect(config)),
+      onAcquire: config.onAcquire ? Effect.andThen(follow, config.onAcquire) : follow,
+    })
+  })