effect-vercel 0.2.0 → 0.4.0

package/dist/runtime-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-cache.js","names":[],"sources":["../src/VercelRuntimeCache.ts"],"sourcesContent":["/**\n * Effect `Persistence` backed by the Vercel Runtime Cache, so a\n * `PersistedCache` shares results across Function instances in a region.\n *\n * Outside Vercel, `getCache` falls back to an in-memory cache, so the same\n * layer works in local dev and tests.\n *\n * @example\n * ```ts\n * import { VercelRuntimeCache } from \"effect-vercel/runtime-cache\"\n * import { Effect } from \"effect\"\n * import { PersistedCache } from \"effect/persistence\"\n *\n * const program = Effect.gen(function* () {\n *   const users = yield* PersistedCache.make(fetchUser, {\n *     storeId: \"users\",\n *     timeToLive: () => \"1 hour\",\n *   })\n *   return yield* users.get(new GetUser({ id: 1 }))\n * }).pipe(Effect.scoped, Effect.provide(VercelRuntimeCache.layer))\n * ```\n */\n\nimport { createHash } from \"node:crypto\"\nimport { getCache, type RuntimeCache } from \"@vercel/functions\"\nimport { Duration, Effect, Layer } from \"effect\"\nimport { Persistence } from \"effect/persistence\"\n\nconst sha256 = (key: string) => createHash(\"sha256\").update(key).digest(\"hex\")\n\n/**\n * A `BackingPersistence` over `cache`.\n *\n * Entries are keyed by the JSON pair `[storeId, key]`, so no two stores share\n * a key. Each entry is tagged with a hash of the store id, since tags are\n * joined with `,` and sent unescaped, and `clear` expires that tag. Entries\n * are sent without a name, so keys don't reach Vercel's o11y or the request\n * headers, where non-Latin-1 characters would make the write fail. TTLs round\n * up to whole seconds, the cache's resolution.\n *\n * `getCache()` hashes keys with a 32-bit hash by default, which can collide.\n * Pass a cache made with a stronger `keyHashFunction`, as `layerBacking` does.\n */\nexport const makeBacking = (cache: RuntimeCache): Persistence.BackingPersistence[\"Service\"] =>\n  Persistence.BackingPersistence.of({\n    make: (storeId) =>\n      Effect.sync(() => {\n        const prefixed = (key: string) => JSON.stringify([storeId, key])\n        const tag = `effect-persistence:${sha256(storeId)}`\n\n        const get = (key: string) =>\n          Effect.tryPromise({\n            try: () => cache.get(prefixed(key)),\n            catch: (cause) =>\n              new Persistence.PersistenceError({ message: `Failed to get key ${key}`, cause }),\n          }).pipe(\n            Effect.map((value) =>\n              typeof value === \"object\" && value !== null ? value : undefined,\n            ),\n          )\n\n        const set = (key: string, value: object, ttl: Duration.Duration | undefined) =>\n          Effect.tryPromise({\n            try: () =>\n              cache.set(prefixed(key), value, {\n                name: \"\",\n                tags: [tag],\n                ...(ttl && { ttl: Math.max(1, Math.ceil(Duration.toSeconds(ttl))) }),\n              }),\n            catch: (cause) =>\n              new Persistence.PersistenceError({ message: `Failed to set key ${key}`, cause }),\n          })\n\n        return {\n          get,\n          getMany: (keys) => Effect.forEach(keys, get, { concurrency: \"unbounded\" }),\n          set,\n          // Writes run concurrently, so keep only the last entry for each key.\n          setMany: (entries) =>\n            Effect.forEach(\n              new Map(entries.map(([key, value, ttl]) => [key, [value, ttl] as const])),\n              ([key, [value, ttl]]) => set(key, value, ttl),\n              { concurrency: \"unbounded\", discard: true },\n            ),\n          remove: (key) =>\n            Effect.tryPromise({\n              try: () => cache.delete(prefixed(key)),\n              catch: (cause) =>\n                new Persistence.PersistenceError({ message: `Failed to remove key ${key}`, cause }),\n            }),\n          clear: Effect.tryPromise({\n            try: () => cache.expireTag(tag),\n            catch: (cause) =>\n              new Persistence.PersistenceError({ message: `Failed to clear ${storeId}`, cause }),\n          }),\n        }\n      }),\n  })\n\n/** `BackingPersistence` over `getCache()`, with SHA-256 key hashing. */\nexport const layerBacking: Layer.Layer<Persistence.BackingPersistence> = Layer.sync(\n  Persistence.BackingPersistence,\n)(() => makeBacking(getCache({ keyHashFunction: sha256 })))\n\n/** `Persistence` backed by the Vercel Runtime Cache. */\nexport const layer: Layer.Layer<Persistence.Persistence> = Persistence.layer.pipe(\n  Layer.provide(layerBacking),\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAM,UAAU,QAAgB,WAAW,QAAQ,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,KAAK;;;;;;;;;;;;;;AAe7E,MAAa,eAAe,UAC1B,YAAY,mBAAmB,GAAG,EAChC,OAAO,YACL,OAAO,WAAW;CAChB,MAAM,YAAY,QAAgB,KAAK,UAAU,CAAC,SAAS,GAAG,CAAC;CAC/D,MAAM,MAAM,sBAAsB,OAAO,OAAO;CAEhD,MAAM,OAAO,QACX,OAAO,WAAW;EAChB,WAAW,MAAM,IAAI,SAAS,GAAG,CAAC;EAClC,QAAQ,UACN,IAAI,YAAY,iBAAiB;GAAE,SAAS,qBAAqB;GAAO;EAAM,CAAC;CACnF,CAAC,CAAC,CAAC,KACD,OAAO,KAAK,UACV,OAAO,UAAU,YAAY,UAAU,OAAO,QAAQ,KAAA,CACxD,CACF;CAEF,MAAM,OAAO,KAAa,OAAe,QACvC,OAAO,WAAW;EAChB,WACE,MAAM,IAAI,SAAS,GAAG,GAAG,OAAO;GAC9B,MAAM;GACN,MAAM,CAAC,GAAG;GACV,GAAI,OAAO,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,SAAS,UAAU,GAAG,CAAC,CAAC,EAAE;EACpE,CAAC;EACH,QAAQ,UACN,IAAI,YAAY,iBAAiB;GAAE,SAAS,qBAAqB;GAAO;EAAM,CAAC;CACnF,CAAC;CAEH,OAAO;EACL;EACA,UAAU,SAAS,OAAO,QAAQ,MAAM,KAAK,EAAE,aAAa,YAAY,CAAC;EACzE;EAEA,UAAU,YACR,OAAO,QACL,IAAI,IAAI,QAAQ,KAAK,CAAC,KAAK,OAAO,SAAS,CAAC,KAAK,CAAC,OAAO,GAAG,CAAU,CAAC,CAAC,IACvE,CAAC,KAAK,CAAC,OAAO,UAAU,IAAI,KAAK,OAAO,GAAG,GAC5C;GAAE,aAAa;GAAa,SAAS;EAAK,CAC5C;EACF,SAAS,QACP,OAAO,WAAW;GAChB,WAAW,MAAM,OAAO,SAAS,GAAG,CAAC;GACrC,QAAQ,UACN,IAAI,YAAY,iBAAiB;IAAE,SAAS,wBAAwB;IAAO;GAAM,CAAC;EACtF,CAAC;EACH,OAAO,OAAO,WAAW;GACvB,WAAW,MAAM,UAAU,GAAG;GAC9B,QAAQ,UACN,IAAI,YAAY,iBAAiB;IAAE,SAAS,mBAAmB;IAAW;GAAM,CAAC;EACrF,CAAC;CACH;AACF,CAAC,EACL,CAAC;;AAGH,MAAa,eAA4D,MAAM,KAC7E,YAAY,kBACd,CAAC,OAAO,YAAY,SAAS,EAAE,iBAAiB,OAAO,CAAC,CAAC,CAAC;;AAG1D,MAAa,QAA8C,YAAY,MAAM,KAC3E,MAAM,QAAQ,YAAY,CAC5B"}

package/src/VercelOidc.ts

@@ -1,86 +0,0 @@
-/**
- * The OIDC token Vercel issues to a deployment.
- *
- * In Functions the token arrives on each request as the `x-vercel-oidc-token`
- * header and rotates, so it is read on every run of `token`/`find`, never
- * cached. In builds and after `vercel env pull` it is `VERCEL_OIDC_TOKEN`.
- * Use it to authenticate to the AI Gateway, or exchange it for cloud
- * credentials (AWS `AssumeRoleWithWebIdentity`, GCP workload identity
- * federation).
- *
- * @example
- * ```ts
- * import { VercelOidc } from "effect-vercel/oidc"
- * import { Effect, Redacted } from "effect"
- *
- * const program = Effect.gen(function* () {
- *   const token = yield* VercelOidc.token
- *   // pass Redacted.value(token) as the web identity token
- * })
- * ```
- */
-
-import { Config, Data, Effect, Option, Redacted } from "effect"
-
-/** The environment variable read when no request carries a token. */
-export const TOKEN_ENV = "VERCEL_OIDC_TOKEN"
-
-/** No usable OIDC token. */
-export class VercelOidcError extends Data.TaggedError("VercelOidcError")<{
-  readonly message: string
-  readonly hints: ReadonlyArray<string>
-  readonly cause?: unknown
-}> {}
-
-/** How to make a token available. */
-export const hints: ReadonlyArray<string> = [
-  "Run on Vercel, where each request carries an OIDC token.",
-  `Or run \`vercel env pull\` locally to populate ${TOKEN_ENV}.`,
-]
-
-/**
- * Vercel exposes the current request's context on a well-known global symbol.
- * In Functions, the `x-vercel-oidc-token` header of the request lives there.
- * Mirrors `@vercel/oidc`'s `getVercelOidcTokenSync`, minus the dev-time
- * refresh that package also offers.
- */
-const REQUEST_CONTEXT = Symbol.for("@vercel/request-context")
-
-type RequestContext = { readonly headers?: Record<string, string | undefined> }
-
-const fromRequestContext = Effect.sync(() => {
-  const holder = globalThis as typeof globalThis & {
-    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }
-  }
-  return Option.fromNullishOr(
-    holder[REQUEST_CONTEXT]?.get?.()?.headers?.["x-vercel-oidc-token"],
-  ).pipe(Option.map(Redacted.make))
-})
-
-const fromEnv = Config.option(Config.Redacted(TOKEN_ENV)).pipe(
-  Effect.catchTag(
-    "ConfigError",
-    (cause) => new VercelOidcError({ message: `Failed to read ${TOKEN_ENV}.`, hints, cause }),
-  ),
-)
-
-/**
- * The token if one is available: the request header, else `VERCEL_OIDC_TOKEN`.
- * `None` means neither is set, so a caller can fall back to something else.
- */
-export const find: Effect.Effect<
-  Option.Option<Redacted.Redacted<string>>,
-  VercelOidcError
-> = Effect.flatMap(fromRequestContext, (found) =>
-  Option.isSome(found) ? Effect.succeed(found) : fromEnv,
-)
-
-/** Like `find`, but fails when no token is available. */
-export const token: Effect.Effect<Redacted.Redacted<string>, VercelOidcError> = Effect.flatMap(
-  find,
-  Option.match({
-    onNone: () =>
-      Effect.fail(new VercelOidcError({ message: "No Vercel OIDC token is available.", hints })),
-    onSome: Effect.succeed,
-  }),
-)

package/src/ai-gateway.ts

@@ -1,2 +0,0 @@
-export * as AiGateway from "./AiGateway.js"
-export * as AiGatewayCredentials from "./AiGatewayCredentials.js"

package/src/oidc.ts

@@ -1 +0,0 @@
-export * as VercelOidc from "./VercelOidc.js"

package/src/runtime-cache.ts

@@ -1 +0,0 @@
-export * as VercelRuntimeCache from "./VercelRuntimeCache.js"