effect-vercel 0.4.0 → 0.5.0

package/README.md

@@ -11,6 +11,7 @@ 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/RuntimeCache`         | [Runtime Cache](https://vercel.com/docs/runtime-cache) for Effect `Persistence` |
 
@@ -19,7 +20,7 @@ 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
 ```
 
 ## AI Gateway
@@ -120,6 +121,29 @@ 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.
+
 ## 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/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,15 @@
 {
   "name": "effect-vercel",
-  "version": "0.4.0",
-  "description": "Effect integrations for Vercel: AI Gateway, OIDC, Runtime Cache",
+  "version": "0.5.0",
+  "description": "Effect integrations for Vercel: AI Gateway, OIDC, Runtime Cache, waitUntil",
   "keywords": [
     "ai-gateway",
     "effect",
     "effect-ai",
     "oidc",
     "runtime-cache",
-    "vercel"
+    "vercel",
+    "wait-until"
   ],
   "homepage": "https://github.com/duailibe/effect-vercel#readme",
   "bugs": {
@@ -29,6 +30,7 @@
   "exports": {
     "./AiGateway": "./dist/AiGateway.js",
     "./AiGatewayCredentials": "./dist/AiGatewayCredentials.js",
+    "./Functions": "./dist/Functions.js",
     "./Oidc": "./dist/Oidc.js",
     "./RuntimeCache": "./dist/RuntimeCache.js",
     "./package.json": "./package.json"

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()))),
+  )