@neon/env 0.0.0 → 0.8.1

package/dist/lib/env.d.ts

@@ -0,0 +1,410 @@
+import { Config } from "../config/dist/lib/types.js";
+import { NeonApi } from "../config/dist/lib/neon-api.js";
+import "../config/dist/v1.js";
+
+//#region src/lib/env.d.ts
+declare const NEON_ENV_VAR_KEYS: {
+  /**
+   * Branch identity. `NEON_BRANCH` carries the branch **name** and is injected into the
+   * Neon Functions runtime on every branch (including the default) by default. `env pull` /
+   * `neon dev` / `neon-env run` emit it too so local dev mirrors the deployed runtime.
+   */
+  readonly branch: {
+    readonly name: "NEON_BRANCH";
+  };
+  readonly postgres: {
+    readonly databaseUrl: "DATABASE_URL";
+    readonly databaseUrlUnpooled: "DATABASE_URL_UNPOOLED";
+  };
+  readonly auth: {
+    readonly baseUrl: "NEON_AUTH_BASE_URL";
+    readonly jwksUrl: "NEON_AUTH_JWKS_URL";
+  };
+  readonly dataApi: {
+    readonly url: "NEON_DATA_API_URL";
+  };
+  /**
+   * Object storage (Preview). The S3 SDKs read `AWS_*` from their standard config chain, so
+   * a branch credential + `neon dev` / `env pull` makes object storage work from env alone.
+   * `region` is injected under the SDK-standard `AWS_REGION`.
+   */
+  readonly storage: {
+    readonly accessKeyId: "AWS_ACCESS_KEY_ID";
+    readonly secretAccessKey: "AWS_SECRET_ACCESS_KEY";
+    readonly endpoint: "AWS_ENDPOINT_URL_S3";
+    readonly region: "AWS_REGION";
+  };
+  /**
+   * AI Gateway (Preview). Mapped onto the OpenAI SDK's standard env vars so the OpenAI
+   * clients work from env alone; `baseUrl` carries the gateway's OpenAI-dialect route prefix
+   * (`/ai-gateway/openai/v1`). The `NEON_AI_GATEWAY_*` aliases are also emitted: `neonToken`
+   * mirrors the OpenAI key, and `neonBaseUrl` is the bare branch gateway host
+   * (`scheme://host`, no path) — the `@ai-sdk/neon` provider appends the
+   * `/ai-gateway/<dialect>/…` routes itself (https://github.com/vercel/ai/pull/15997).
+   */
+  readonly aiGateway: {
+    readonly apiKey: "OPENAI_API_KEY";
+    readonly baseUrl: "OPENAI_BASE_URL";
+    readonly neonToken: "NEON_AI_GATEWAY_TOKEN";
+    readonly neonBaseUrl: "NEON_AI_GATEWAY_BASE_URL";
+  };
+};
+/**
+ * Branch identity for the resolved branch. Always present on a `fetchEnv` result (the branch
+ * name is always known); on a `parseEnv` result it's present only when `NEON_BRANCH` was
+ * injected into `process.env` (the Functions runtime injects it by default, as do `neon dev` /
+ * `neon-env run` / `env pull`). `name` is the branch **name** (e.g. `main`, `preview/foo`).
+ */
+interface NeonBranchEnv {
+  name: string;
+}
+/** Per-namespace inner shapes. Exposed so consumers can name the parts independently. */
+interface NeonPostgresEnv {
+  /**
+   * Pooled connection string (via Neon's PgBouncer pooler). The right default for
+   * serverless drivers (`@neondatabase/serverless`, edge runtimes, Postgres.js, …).
+   */
+  databaseUrl: string;
+  /**
+   * Direct (unpooled) connection string. Use this when you need session-level
+   * features (`LISTEN`/`NOTIFY`, prepared statements across calls, transactions
+   * spanning round-trips) that PgBouncer's transaction-mode pooling drops.
+   */
+  databaseUrlUnpooled: string;
+}
+/**
+ * Bits of a Neon Auth integration for the resolved branch. Only present on `NeonEnv`
+ * when the branch policy enables `auth`.
+ *
+ * Neon Auth exposes the `baseUrl` (which doubles as the publishable client identifier) and
+ * the `jwksUrl` used to verify tokens it issues. `fetchEnv` reads both from the live
+ * integration; `parseEnv` reads them from `process.env` (`NEON_AUTH_BASE_URL` /
+ * `NEON_AUTH_JWKS_URL`).
+ */
+interface NeonAuthEnv {
+  baseUrl: string;
+  /** JWKS URL for verifying tokens issued by Neon Auth (`NEON_AUTH_JWKS_URL`). */
+  jwksUrl: string;
+}
+/** Bits of a Neon Data API integration. Only present when the branch policy enables it. */
+interface NeonDataApiEnv {
+  url: string;
+}
+/**
+ * S3-compatible object-storage access for the branch (Preview). Present on `NeonEnv` only
+ * when the policy declares `preview.buckets`. Combines a minted branch credential's access
+ * keys (`accessKeyId` = the credential's full token id, e.g. `nak_live_…`, which is what the
+ * storage gateway authenticates against; `secretAccessKey` = its
+ * `s3_secret_access_key`) with the branch's non-secret connection details
+ * (`endpoint`/`region`, from `GET .../storage`). Projects to the AWS SDK's
+ * standard config env (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_ENDPOINT_URL_S3`,
+ * `AWS_REGION`) so the S3 client works from env alone. Neon's storage gateway always
+ * requires path-style addressing, so set `forcePathStyle: true` on your S3 client.
+ */
+interface NeonStorageEnv {
+  accessKeyId: string;
+  secretAccessKey: string;
+  /** S3-compatible endpoint URL for the branch. */
+  endpoint: string;
+  /** AWS region string (e.g. `us-east-2`). Injected as `AWS_REGION`. */
+  region: string;
+}
+/**
+ * AI Gateway access for the branch (Preview). Present on `NeonEnv` only when the policy
+ * enables `preview.aiGateway`. `apiKey` is the minted credential's bearer (`api_token`);
+ * `baseUrl` is the gateway's OpenAI-dialect endpoint on the branch-scoped gateway host
+ * (`https://<branchId>-api.ai.<region>.…/ai-gateway/openai/v1`). Projects to the OpenAI SDK's
+ * standard env (`OPENAI_API_KEY`, `OPENAI_BASE_URL`), plus the `NEON_AI_GATEWAY_*` aliases.
+ */
+interface NeonAiGatewayEnv {
+  apiKey: string;
+  baseUrl: string;
+}
+/**
+ * Empty record alias used as the "false" branch of the conditional namespace adds below.
+ * `Record<never, never>` is the no-op for intersection — the cleaner alternative to `{}`,
+ * which biome rejects (it means "any non-null", not "empty object").
+ */
+type NoNamespace = Record<never, never>;
+/**
+ * Resolve a **static** service toggle (the value of `config.auth` / `config.dataApi`) to a
+ * type-level boolean. The whole-thing wrapping (`[T] extends […]`) turns off distribution
+ * so a union/`undefined` is checked as one unit:
+ *
+ * - `false` / `{ enabled: false }` / `undefined` → `false`
+ * - `true` / `{ enabled: true }` / any other object (`{}`, `{ enabled?: boolean }`) → `true`
+ *   (a present toggle defaults to enabled)
+ * - the bare `boolean | ServiceToggle | undefined` (the default `Config` param, no literal
+ *   info) → `false`, so an untyped policy yields just `{ postgres }`.
+ */
+type ServiceOn<T> = [T] extends [false] ? false : [T] extends [{
+  enabled: false;
+}] ? false : [T] extends [undefined] ? false : [T] extends [true] ? true : [T] extends [{
+  enabled: true;
+}] ? true : [T] extends [object] ? true : false;
+/** True when `T` has at least one known key; `false` for `{}` / `never`. */
+type HasKeys<T> = [keyof T] extends [never] ? false : true;
+/**
+ * Whether the policy's **static** `preview` block declares at least one object-storage bucket
+ * (`preview.buckets`). Drives whether {@link NeonEnv} carries the `storage` namespace.
+ *
+ * The leading `[never]` guard is load-bearing: when a policy has no `preview` at all,
+ * `NonNullable<C["preview"]>` is `never`, and without the guard the `extends { … }` probe
+ * below would vacuously match (everything extends `never`-derived shapes) and `HasKeys<never>`
+ * would resolve `true`, wrongly adding the namespace. The guard short-circuits to `false`.
+ */
+type HasBuckets<C extends Config> = [NonNullable<C["preview"]>] extends [never] ? false : NonNullable<C["preview"]> extends {
+  buckets: infer B;
+} ? HasKeys<NonNullable<B>> : false;
+/**
+ * Whether the policy's **static** `preview` block enables the AI Gateway
+ * (`preview.aiGateway`). Drives whether {@link NeonEnv} carries the `aiGateway` namespace.
+ *
+ * The leading `[never]` guard is load-bearing for the same reason as {@link HasBuckets}: when
+ * a policy has no `preview`, `NonNullable<C["preview"]>` is `never`, and a naked `never` in the
+ * `extends` below would *distribute* (collapsing the result — and the whole `NeonEnv`
+ * intersection — to `never`). The tuple-wrapped guard short-circuits that to `false`.
+ */
+type AiGatewayOn<C extends Config> = [NonNullable<C["preview"]>] extends [never] ? false : NonNullable<C["preview"]> extends {
+  aiGateway: infer A;
+} ? ServiceOn<NonNullable<A>> : false;
+/**
+ * Static, namespaced shape of `fetchEnv` / `parseEnv`'s return value. Generic over the
+ * {@link Config} so the type system knows which optional namespaces are present.
+ *
+ * Because the secret-bearing toggles now live in the **static** top-level `config.auth` /
+ * `config.dataApi` (not inside a per-branch closure), the namespace presence is a direct
+ * read of those fields — no union-across-branches, no default-config escape hatch:
+ *
+ * - `postgres` is always present.
+ * - `auth` is added iff `config.auth` is statically enabled.
+ * - `dataApi` is added iff `config.dataApi` is statically enabled.
+ * - `storage` is added iff `config.preview.buckets` declares at least one bucket.
+ * - `aiGateway` is added iff `config.preview.aiGateway` is statically enabled.
+ */
+type NeonEnv<C extends Config = Config> = {
+  postgres: NeonPostgresEnv;
+  /**
+   * Branch identity (`NEON_BRANCH`). Optional because `parseEnv` only surfaces it when the
+   * var was injected; `fetchEnv` always populates it.
+   */
+  branch?: NeonBranchEnv;
+} & (ServiceOn<NonNullable<C["auth"]>> extends true ? {
+  auth: NeonAuthEnv;
+} : NoNamespace) & (ServiceOn<NonNullable<C["dataApi"]>> extends true ? {
+  dataApi: NeonDataApiEnv;
+} : NoNamespace) & (HasBuckets<C> extends true ? {
+  storage: NeonStorageEnv;
+} : NoNamespace) & (AiGatewayOn<C> extends true ? {
+  aiGateway: NeonAiGatewayEnv;
+} : NoNamespace);
+/** The static `preview.functions` record of a config, or an empty record when absent. */
+type PreviewFunctionsOf<C extends Config> = NonNullable<C["preview"]> extends {
+  functions: infer F;
+} ? F : Record<never, never>;
+/** The declared function slugs of a config (record keys), as a string union. */
+type FunctionSlugOf<C extends Config> = Extract<keyof PreviewFunctionsOf<C>, string>;
+/** The declared env-var keys of one function `S`, as a string union. */
+type FunctionEnvKeysOf<C extends Config, S extends string> = S extends keyof PreviewFunctionsOf<C> ? NonNullable<PreviewFunctionsOf<C>[S]> extends {
+  env: infer E;
+} ? Extract<keyof E, string> : never : never;
+/**
+ * The extra `function` namespace added to `parseEnv`'s result when called with a function
+ * slug scope: the declared env-var keys for that function, each resolved to a `string`.
+ */
+type NeonFunctionEnv<C extends Config, S extends string> = {
+  function: Record<FunctionEnvKeysOf<C, S>, string>;
+};
+/**
+ * OS-level env-var keys grouped by the {@link NeonEnv} namespace they populate. Only the
+ * **input** vars `parseEnv` validates are listed — the output-only aliases in
+ * {@link NEON_ENV_VAR_KEYS} (`NEON_AI_GATEWAY_TOKEN`, …) are intentionally absent, so they
+ * are not selectable in a `parseEnv(config, keys)` filter. Keep in sync with
+ * {@link EnvKeyToProp}.
+ */
+interface EnvKeysByNamespace {
+  postgres: "DATABASE_URL" | "DATABASE_URL_UNPOOLED";
+  auth: "NEON_AUTH_BASE_URL" | "NEON_AUTH_JWKS_URL";
+  dataApi: "NEON_DATA_API_URL";
+  storage: "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" | "AWS_ENDPOINT_URL_S3" | "AWS_REGION";
+  aiGateway: "OPENAI_API_KEY" | "OPENAI_BASE_URL";
+}
+/** The {@link NeonEnv} namespace interface backing each namespace key. */
+interface NamespaceEnv {
+  postgres: NeonPostgresEnv;
+  auth: NeonAuthEnv;
+  dataApi: NeonDataApiEnv;
+  storage: NeonStorageEnv;
+  aiGateway: NeonAiGatewayEnv;
+}
+/** OS-level env-var key → the camelCase property it sets on its namespace object. */
+interface EnvKeyToProp {
+  DATABASE_URL: "databaseUrl";
+  DATABASE_URL_UNPOOLED: "databaseUrlUnpooled";
+  NEON_AUTH_BASE_URL: "baseUrl";
+  NEON_AUTH_JWKS_URL: "jwksUrl";
+  NEON_DATA_API_URL: "url";
+  AWS_ACCESS_KEY_ID: "accessKeyId";
+  AWS_SECRET_ACCESS_KEY: "secretAccessKey";
+  AWS_ENDPOINT_URL_S3: "endpoint";
+  AWS_REGION: "region";
+  OPENAI_API_KEY: "apiKey";
+  OPENAI_BASE_URL: "baseUrl";
+}
+/**
+ * The OS-level env-var keys selectable for a given policy: the union of input vars across
+ * exactly the namespaces {@link NeonEnv}<C> carries. Drives the typesafe autocomplete of the
+ * `keys` filter — selecting a var from a namespace the policy does not enable is a type error
+ * (e.g. `NEON_AUTH_BASE_URL` is only offered once the policy turns on `auth`).
+ */
+type SelectableEnvKey<C extends Config> = EnvKeysByNamespace[keyof NeonEnv<C> & keyof EnvKeysByNamespace];
+/**
+ * The result shape of a **filtered** `parseEnv(config, keys)` call: the namespaced
+ * {@link NeonEnv} restricted to exactly the selected OS-level keys `K`. Namespaces with no
+ * selected key are dropped, and within a kept namespace only the selected properties survive
+ * — selecting just `["DATABASE_URL"]` yields `{ postgres: { databaseUrl: string } }`, with no
+ * `databaseUrlUnpooled`.
+ *
+ * The policy gating lives on the `parseEnv` overload (which binds `K` to
+ * {@link SelectableEnvKey}); this type only needs the selection, so it takes a bare
+ * `K extends string` and filters with `Extract`. The outer mapped type's `as` clause drops
+ * any namespace whose intersection with the selection is empty (`[…] extends [never]`,
+ * tuple-wrapped to switch off distribution); the inner one re-keys each selected OS var to its
+ * camelCase property and looks the value type up on the canonical namespace interface, so it
+ * stays correct if a field ever stops being a plain `string`.
+ */
+type FilteredNeonEnv<K extends string> = { [N in keyof EnvKeysByNamespace as [Extract<K, EnvKeysByNamespace[N]>] extends [never] ? never : N]: { [P in Extract<K, EnvKeysByNamespace[N]> as EnvKeyToProp[P & keyof EnvKeyToProp]]: NamespaceEnv[N][EnvKeyToProp[P & keyof EnvKeyToProp] & keyof NamespaceEnv[N]] } };
+interface FetchEnvOptions {
+  /**
+   * Neon project id. **Required** — the management API addresses branches through their
+   * project. Resolve it in your CLI (e.g. neonctl) and pass it in.
+   */
+  projectId: string;
+  /** Neon branch id (`br-…`). **Required.** Resolve names to ids before calling. */
+  branchId: string;
+  /**
+   * Neon API key. Resolved via the standard chain (option → `NEON_API_KEY` →
+   * `~/.config/neonctl/credentials.json`) when omitted. Ignored when a custom `api`
+   * is supplied.
+   */
+  apiKey?: string;
+  /**
+   * Neon **management** API base URL (not the Auth base URL). Falls back to
+   * `NEON_API_HOST`, then production. Ignored when a custom `api` is supplied.
+   */
+  apiHost?: string;
+  /**
+   * Inject a custom NeonApi adapter. Primarily used by tests; production callers can rely
+   * on the default real adapter built from `apiKey`.
+   */
+  api?: NeonApi;
+  /**
+   * Role name to fetch credentials for. When omitted, the connection role is auto-picked:
+   * the only role on the branch, else Neon's default owner (`neondb_owner`), else the
+   * single role left after dropping the managed Auth/Data API roles
+   * (`authenticator`/`anonymous`/`authenticated`). Throws {@link PlatformError} with
+   * `PLATFORM_AMBIGUOUS_BRANCH_AUTH` only when more than one app role remains.
+   */
+  roleName?: string;
+  /**
+   * Database name. When omitted, the only database on the branch is auto-picked; throws
+   * {@link PlatformError} with `PLATFORM_AMBIGUOUS_BRANCH_AUTH` if the branch has more
+   * than one database.
+   */
+  databaseName?: string;
+  /**
+   * Env source used for one-time Auth keys that cannot be refetched after integration
+   * creation. Defaults to `process.env`; callers may layer values from `.env.local`.
+   */
+  env?: NodeJS.ProcessEnv;
+}
+/**
+ * Resolve the project + branch this process should target, then fetch live Neon
+ * connection strings for that branch over the network. Async — calls the Neon API.
+ *
+ * Use this from build scripts and the `neon-env run` command, where top-level await is
+ * fine. For application code that needs a synchronous bootstrap (most frameworks: Drizzle
+ * config, Next.js, Vite, etc.), inject env vars via `neon-env run -- <cmd>` and use
+ * {@link parseEnv} instead — same {@link NeonEnv} shape, but a sync call against
+ * `process.env`.
+ *
+ * Filesystem- and env-agnostic: pass `projectId` and the target `branchId` explicitly
+ * (resolve them in your CLI, e.g. neonctl).
+ *
+ * ```ts
+ * import config from "../neon";
+ * import { fetchEnv } from "@neon/env";
+ *
+ * const env = await fetchEnv(config, { projectId: "patient-art-12345", branchId: "br-…" });
+ * const db = drizzle(neon(env.postgres.databaseUrl), { schema });
+ * ```
+ *
+ * The package does **not** mutate `process.env` or the filesystem itself.
+ */
+declare function fetchEnv<const C extends Config>(config: C, options: FetchEnvOptions): Promise<NeonEnv<C>>;
+/**
+ * Synchronous, network-free counterpart to {@link fetchEnv}. Reads `process.env`, validates
+ * the required Neon env vars with zod, and returns the same {@link NeonEnv} shape — so the
+ * rest of your app touches `env.postgres.databaseUrl` instead of stringly-typed
+ * `process.env.DATABASE_URL` lookups.
+ *
+ * Designed for the **"env-vars-already-injected"** path:
+ * - You wrapped your dev command with `neon-env run -- <cmd>` or `neon dev`.
+ * - Your platform (Vercel, Fly, Railway, …) injected the vars via its own integration.
+ * - You are **inside a deployed Neon Function**, whose env was uploaded at `config apply`.
+ *
+ * Unlike the old API, `parseEnv` does **not** take a branch name: the secret set is now
+ * static (top-level `config.auth` / `config.dataApi`), so it reads those directly without
+ * evaluating the per-branch closure.
+ *
+ * The second argument is a **scope** or a **key filter**:
+ * - omitted — *external* scope (app bootstrap, build scripts, your dev machine). Returns the
+ *   full `{ postgres, auth?, dataApi?, … }` the policy enables.
+ * - a **function slug** (a key of `config.preview.functions`) — *function* scope: you are
+ *   running inside that function. Returns the same branch secrets **plus** a typed
+ *   `function` namespace with the function's declared env-var keys.
+ * - an **array of OS-level env-var keys** (e.g. `["DATABASE_URL", "NEON_AUTH_BASE_URL"]`) —
+ *   *filtered* mode: only those vars are required and returned, as a narrowed namespaced
+ *   shape. The keys autocomplete from the policy ({@link SelectableEnvKey}), so you can only
+ *   pick vars the policy actually enables. Use this when a process needs just a subset (a
+ *   Next.js app that reads `DATABASE_URL` but not `DATABASE_URL_UNPOOLED`, say) and you don't
+ *   want `parseEnv` to throw over vars you never use.
+ *
+ * Throws `PlatformError(EnvNotInjected)` listing every missing/invalid var when the env
+ * isn't fully populated, with a fix hint pointing back at `neon dev` / `neon-env run`.
+ *
+ * ```ts
+ * import config from "../neon";
+ * import { parseEnv } from "@neon/env";
+ *
+ * // External (app / build):
+ * const env = parseEnv(config);
+ * const db = drizzle(neon(env.postgres.databaseUrl), { schema });
+ *
+ * // Inside the "hello" function:
+ * const env = parseEnv(config, "hello");
+ * env.function.resendApiKey; // typed from hello's declared env keys
+ *
+ * // Filtered: only enforce + return the pooled URL.
+ * const { postgres } = parseEnv(config, ["DATABASE_URL"]);
+ * postgres.databaseUrl; // string — `databaseUrlUnpooled` is absent
+ * ```
+ */
+declare function parseEnv<const C extends Config>(config: C): NeonEnv<C>;
+declare function parseEnv<const C extends Config, const K extends SelectableEnvKey<C>>(config: C, keys: readonly K[]): FilteredNeonEnv<K>;
+declare function parseEnv<const C extends Config, const S extends FunctionSlugOf<C>>(config: C, scope: S): NeonEnv<C> & NeonFunctionEnv<C, S>;
+/**
+ * Project a fully-resolved {@link NeonEnv} into the OS-level `{ KEY: value }` pairs used
+ * for cross-process transport. Named after the web-platform `.entries()` convention
+ * (`URLSearchParams` / `Headers` / `FormData`); returns a `Record` rather than an
+ * iterator of tuples since that's the shape env injection needs (wrap with
+ * `Object.entries(...)` if you want literal `[key, value]` pairs). Used by `neon-env run`
+ * to inject the vars into a subprocess's `process.env`.
+ *
+ * Walks the value at runtime so it works for any `NeonEnv<C>` regardless of which
+ * conditional namespaces are present.
+ */
+declare function toEntries(env: NeonEnv<Config>): Record<string, string>;
+//#endregion
+export { FetchEnvOptions, FilteredNeonEnv, FunctionSlugOf, NEON_ENV_VAR_KEYS, NeonAiGatewayEnv, NeonAuthEnv, NeonBranchEnv, NeonDataApiEnv, NeonEnv, NeonFunctionEnv, NeonPostgresEnv, NeonStorageEnv, SelectableEnvKey, fetchEnv, parseEnv, toEntries };
+//# sourceMappingURL=env.d.ts.map

package/dist/lib/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","names":[],"sources":["../../src/lib/env.ts"],"mappings":"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"}