@vercel/functions 2.2.4 → 2.2.6

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @vercel/functions
 
+## 2.2.6
+
+### Patch Changes
+
+- Introduce attachDatabasePool function ([#13632](https://github.com/vercel/vercel/pull/13632))
+
+## 2.2.5
+
+### Patch Changes
+
+- extract oidc and aws oidc credential helpers from @vercel/functions into @vercel/oidc and @vercel/oidc-aws-credentials-provider. @vercel/functions re-exports the new functions as deprecated to maintain backwards compatibility. ([#13548](https://github.com/vercel/vercel/pull/13548))
+
+- Updated dependencies [[`fa8d4c76ea50c4844031f56209b21845818212fc`](https://github.com/vercel/vercel/commit/fa8d4c76ea50c4844031f56209b21845818212fc)]:
+  - @vercel/oidc@2.0.0
+
+## 2.2.5
+
+### Patch Changes
+
+- Extract oidc behavior into separate packages ([#13548](https://github.com/vercel/vercel/pull/13548))
+
 ## 2.2.4
 
 ### Patch Changes

package/db-connections/index.d.ts

@@ -0,0 +1,81 @@
+interface PgPool {
+    options?: {
+        idleTimeoutMillis?: number | null;
+    };
+    on?: (event: 'release', listener: (...args: any[]) => void) => void;
+}
+interface MySQLPool {
+    config?: {
+        connectionConfig?: {
+            idleTimeout?: number;
+        };
+    };
+    on?: (event: 'release', listener: (...args: any[]) => void) => void;
+}
+interface MySQL2Pool {
+    config?: {
+        idleTimeout?: number;
+    };
+    on?: (event: 'release', listener: (...args: any[]) => void) => void;
+}
+interface MariaDBPool {
+    config?: {
+        idleTimeout?: number;
+    };
+    on?: (event: 'release', listener: (...args: any[]) => void) => void;
+}
+interface MongoDBPool {
+    options?: {
+        maxIdleTimeMS?: number;
+    };
+    on?: (event: 'connectionCheckedOut' | 'connectionCheckedIn' | 'connectionPoolCreated' | 'connectionPoolClosed' | 'connectionCreated' | 'connectionReady' | 'connectionClosed', listener: (...args: any[]) => void) => void;
+}
+interface RedisPool {
+    options?: any;
+    on?: (event: 'ready' | 'end' | 'error' | 'connect', listener: (...args: any[]) => void) => void;
+    status?: string;
+}
+interface CassandraPool {
+    connect?: (callback?: (err?: Error) => void) => Promise<void>;
+    execute?: (query: string, params?: any[], options?: any) => Promise<any>;
+}
+/**
+ * The database pool object. The supported pool types are:
+ * - PostgreSQL (pg)
+ * - MySQL2
+ * - MariaDB
+ * - MongoDB
+ * - Redis (ioredis)
+ * - Cassandra (cassandra-driver)
+ * - OTHER: This method uses duck-typing to detect the pool type. Respectively you can
+ *   pass in any object with a compatible interface.
+ */
+export type DbPool = PgPool | MySQLPool | MySQL2Pool | MariaDBPool | MongoDBPool | RedisPool | CassandraPool;
+/**
+ * Call this function right after creating a database pool with the database pool object
+ * as argument.
+ * This ensures that the current function instance stays alive long enough for
+ * idle database connections to be removed from the pool.
+ *
+ * @param dbPool - The database pool object. The supported pool types are:
+ * - PostgreSQL (pg)
+ * - MySQL2
+ * - MariaDB
+ * - MongoDB
+ * - Redis (ioredis)
+ * - Cassandra (cassandra-driver)
+ * - OTHER: This method uses duck-typing to detect the pool type. Respectively you can
+ *   pass in any object with a compatible interface.
+ *
+ * @example
+ * ```ts
+ * const pgPool = new Pool({
+ *   connectionString: process.env.DATABASE_URL,
+ * });
+ * experimental_attachDatabasePool(pgPool);
+ * ```
+ *
+ * @experimental
+ */
+export declare function experimental_attachDatabasePool(dbPool: DbPool): void;
+export {};

package/db-connections/index.js

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var db_connections_exports = {};
+__export(db_connections_exports, {
+  experimental_attachDatabasePool: () => experimental_attachDatabasePool
+});
+module.exports = __toCommonJS(db_connections_exports);
+var import_get_context = require("../get-context");
+const DEBUG = !!process.env.DEBUG;
+function getIdleTimeout(dbPool) {
+  if ("options" in dbPool && dbPool.options) {
+    if ("idleTimeoutMillis" in dbPool.options) {
+      return typeof dbPool.options.idleTimeoutMillis === "number" ? dbPool.options.idleTimeoutMillis : 1e4;
+    }
+    if ("maxIdleTimeMS" in dbPool.options) {
+      return typeof dbPool.options.maxIdleTimeMS === "number" ? dbPool.options.maxIdleTimeMS : 0;
+    }
+    if ("status" in dbPool) {
+      return 5e3;
+    }
+    if ("connect" in dbPool && "execute" in dbPool) {
+      return 3e4;
+    }
+  }
+  if ("config" in dbPool && dbPool.config) {
+    if ("connectionConfig" in dbPool.config && dbPool.config.connectionConfig) {
+      return dbPool.config.connectionConfig.idleTimeout || 6e4;
+    }
+    if ("idleTimeout" in dbPool.config) {
+      return typeof dbPool.config.idleTimeout === "number" ? dbPool.config.idleTimeout : 6e4;
+    }
+  }
+  if ("poolTimeout" in dbPool) {
+    return typeof dbPool.poolTimeout === "number" ? dbPool.poolTimeout : 6e4;
+  }
+  if ("idleTimeout" in dbPool) {
+    return typeof dbPool.idleTimeout === "number" ? dbPool.idleTimeout : 0;
+  }
+  return 1e4;
+}
+let idleTimeout = null;
+let idleTimeoutResolve = () => {
+};
+const bootTime = Date.now();
+const maximumDuration = 15 * 60 * 1e3 - 1e3;
+function waitUntilIdleTimeout(dbPool) {
+  if (idleTimeout) {
+    clearTimeout(idleTimeout);
+    idleTimeoutResolve();
+  }
+  const promise = new Promise((resolve) => {
+    idleTimeoutResolve = resolve;
+  });
+  const waitTime = Math.min(
+    getIdleTimeout(dbPool) + 100,
+    maximumDuration - (Date.now() - bootTime)
+  );
+  idleTimeout = setTimeout(() => {
+    idleTimeoutResolve?.();
+    if (DEBUG) {
+      console.log("Database pool idle timeout reached. Releasing connections.");
+    }
+  }, waitTime);
+  const requestContext = (0, import_get_context.getContext)();
+  if (requestContext?.waitUntil) {
+    requestContext.waitUntil(promise);
+  } else {
+    console.warn("Pool release event triggered outside of request scope.");
+  }
+}
+function experimental_attachDatabasePool(dbPool) {
+  if (idleTimeout) {
+    idleTimeoutResolve?.();
+    clearTimeout(idleTimeout);
+  }
+  if ("on" in dbPool && dbPool.on && "options" in dbPool && "idleTimeoutMillis" in dbPool.options) {
+    const pgPool = dbPool;
+    pgPool.on("release", () => {
+      if (DEBUG) {
+        console.log("Client released from pool");
+      }
+      waitUntilIdleTimeout(dbPool);
+    });
+    return;
+  } else if ("on" in dbPool && dbPool.on && "config" in dbPool && dbPool.config && "connectionConfig" in dbPool.config) {
+    const mysqlPool = dbPool;
+    mysqlPool.on("release", () => {
+      if (DEBUG) {
+        console.log("MySQL client released from pool");
+      }
+      waitUntilIdleTimeout(dbPool);
+    });
+    return;
+  } else if ("on" in dbPool && dbPool.on && "config" in dbPool && dbPool.config && "idleTimeout" in dbPool.config) {
+    const mysql2Pool = dbPool;
+    mysql2Pool.on("release", () => {
+      if (DEBUG) {
+        console.log("MySQL2/MariaDB client released from pool");
+      }
+      waitUntilIdleTimeout(dbPool);
+    });
+    return;
+  }
+  if ("on" in dbPool && dbPool.on && "options" in dbPool && dbPool.options && "maxIdleTimeMS" in dbPool.options) {
+    const mongoPool = dbPool;
+    mongoPool.on("connectionCheckedOut", () => {
+      if (DEBUG) {
+        console.log("MongoDB connection checked out");
+      }
+      waitUntilIdleTimeout(dbPool);
+    });
+    return;
+  }
+  if ("on" in dbPool && dbPool.on && "options" in dbPool && dbPool.options && "socket" in dbPool.options) {
+    const redisPool = dbPool;
+    redisPool.on("end", () => {
+      if (DEBUG) {
+        console.log("Redis connection ended");
+      }
+      waitUntilIdleTimeout(dbPool);
+    });
+    return;
+  }
+  throw new Error("Unsupported database pool type");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  experimental_attachDatabasePool
+});

package/db-connections/type-assertion.d.ts

@@ -0,0 +1,13 @@
+import type { Pool as PgPoolType } from 'pg';
+import type { Pool as MySQL2PoolType } from 'mysql2/promise';
+import type { Pool as MariaDBPoolType } from 'mariadb';
+import type { MongoClient as MongoDBClientType } from 'mongodb';
+import type { Redis as IoRedisType } from 'ioredis';
+import type { Client as CassandraClientType } from 'cassandra-driver';
+import type { DbPool } from '.';
+export declare const pgSubtypeCheck: (pool: PgPoolType) => DbPool;
+export declare const mysql2SubtypeCheck: (pool: MySQL2PoolType) => DbPool;
+export declare const mariadbSubtypeCheck: (pool: MariaDBPoolType) => DbPool;
+export declare const mongoSubtypeCheck: (client: MongoDBClientType) => DbPool;
+export declare const ioredisSubtypeCheck: (redis: IoRedisType) => DbPool;
+export declare const cassandraSubtypeCheck: (client: CassandraClientType) => DbPool;

package/{oidc/get-vercel-oidc-token.js → db-connections/type-assertion.js}

@@ -16,27 +16,29 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var get_vercel_oidc_token_exports = {};
-__export(get_vercel_oidc_token_exports, {
-  getVercelOidcToken: () => getVercelOidcToken,
-  getVercelOidcTokenSync: () => getVercelOidcTokenSync
+var type_assertion_exports = {};
+__export(type_assertion_exports, {
+  cassandraSubtypeCheck: () => cassandraSubtypeCheck,
+  ioredisSubtypeCheck: () => ioredisSubtypeCheck,
+  mariadbSubtypeCheck: () => mariadbSubtypeCheck,
+  mongoSubtypeCheck: () => mongoSubtypeCheck,
+  mysql2SubtypeCheck: () => mysql2SubtypeCheck,
+  pgSubtypeCheck: () => pgSubtypeCheck
 });
-module.exports = __toCommonJS(get_vercel_oidc_token_exports);
-var import_get_context = require("../get-context");
-async function getVercelOidcToken() {
-  return getVercelOidcTokenSync();
-}
-function getVercelOidcTokenSync() {
-  const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
-  if (!token) {
-    throw new Error(
-      `The 'x-vercel-oidc-token' header is missing from the request. Do you have the OIDC option enabled in the Vercel project settings?`
-    );
-  }
-  return token;
-}
+module.exports = __toCommonJS(type_assertion_exports);
+const pgSubtypeCheck = (pool) => pool;
+const mysql2SubtypeCheck = (pool) => pool;
+const mariadbSubtypeCheck = (pool) => pool;
+const mongoSubtypeCheck = (client) => client;
+const ioredisSubtypeCheck = (redis) => redis;
+const cassandraSubtypeCheck = (client) => client;
+throw new Error("This file is not used in the codebase.");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getVercelOidcToken,
-  getVercelOidcTokenSync
+  cassandraSubtypeCheck,
+  ioredisSubtypeCheck,
+  mariadbSubtypeCheck,
+  mongoSubtypeCheck,
+  mysql2SubtypeCheck,
+  pgSubtypeCheck
 });

package/docs/modules/index.md

@@ -10,6 +10,7 @@
 
 ### Functions
 
+- [experimental_attachDatabasePool](index.md#experimental_attachdatabasepool)
 - [geolocation](index.md#geolocation)
 - [getCache](index.md#getcache)
 - [getEnv](index.md#getenv)
@@ -20,6 +21,40 @@
 
 ## Functions
 
+### experimental_attachDatabasePool
+
+▸ **experimental_attachDatabasePool**(`dbPool`): `void`
+
+Call this function right after creating a database pool with the database pool object
+as argument.
+This ensures that the current function instance stays alive long enough for
+idle database connections to be removed from the pool.
+
+**`Example`**
+
+```ts
+const pgPool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+experimental_attachDatabasePool(pgPool);
+```
+
+#### Parameters
+
+| Name     | Type     | Description                                                                                                                                                                                                                                                                                 |
+| :------- | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `dbPool` | `DbPool` | The database pool object. The supported pool types are: - PostgreSQL (pg) - MySQL2 - MariaDB - MongoDB - Redis (ioredis) - Cassandra (cassandra-driver) - OTHER: This method uses duck-typing to detect the pool type. Respectively you can pass in any object with a compatible interface. |
+
+#### Returns
+
+`void`
+
+#### Defined in
+
+[packages/functions/src/db-connections/index.ts:217](https://github.com/vercel/vercel/blob/main/packages/functions/src/db-connections/index.ts#L217)
+
+---
+
 ### geolocation
 
 ▸ **geolocation**(`request`): [`Geo`](../interfaces/index.Geo.md)

package/docs/modules/oidc.md

@@ -97,7 +97,7 @@ A promise that resolves to the OIDC token.
 
 #### Defined in
 
-[packages/functions/src/oidc/get-vercel-oidc-token.ts:25](https://github.com/vercel/vercel/blob/main/packages/functions/src/oidc/get-vercel-oidc-token.ts#L25)
+packages/oidc/dist/get-vercel-oidc-token.d.ts:23
 
 ---
 
@@ -132,4 +132,4 @@ The OIDC token.
 
 #### Defined in
 
-[packages/functions/src/oidc/get-vercel-oidc-token.ts:48](https://github.com/vercel/vercel/blob/main/packages/functions/src/oidc/get-vercel-oidc-token.ts#L48)
+packages/oidc/dist/get-vercel-oidc-token.d.ts:43

package/index.d.ts

@@ -4,4 +4,5 @@ export { getEnv } from './get-env';
 export { waitUntil } from './wait-until';
 export { rewrite, next } from './middleware';
 export { getCache } from './cache';
+export { experimental_attachDatabasePool } from './db-connections';
 export type { RuntimeCache } from './cache/types';

package/index.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
+  experimental_attachDatabasePool: () => import_db_connections.experimental_attachDatabasePool,
   geolocation: () => import_headers.geolocation,
   getCache: () => import_cache.getCache,
   getEnv: () => import_get_env.getEnv,
@@ -32,8 +33,10 @@ var import_get_env = require("./get-env");
 var import_wait_until = require("./wait-until");
 var import_middleware = require("./middleware");
 var import_cache = require("./cache");
+var import_db_connections = require("./db-connections");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  experimental_attachDatabasePool,
   geolocation,
   getCache,
   getEnv,

package/oidc/aws-credentials-provider.js

@@ -31,13 +31,13 @@ __export(aws_credentials_provider_exports, {
   awsCredentialsProvider: () => awsCredentialsProvider
 });
 module.exports = __toCommonJS(aws_credentials_provider_exports);
-var import_get_vercel_oidc_token = require("./get-vercel-oidc-token");
+var import_oidc = require("@vercel/oidc");
 function awsCredentialsProvider(init) {
   return async () => {
     const { fromWebToken } = await import("@aws-sdk/credential-provider-web-identity");
     return fromWebToken({
       ...init,
-      webIdentityToken: (0, import_get_vercel_oidc_token.getVercelOidcTokenSync)()
+      webIdentityToken: (0, import_oidc.getVercelOidcTokenSync)()
     })();
   };
 }

package/oidc/index.d.ts

@@ -1,3 +1,15 @@
+/**
+ * @deprecated Use @vercel/oidc-aws-credentials-provider instead
+ * AWS authentication for Vercel Functions
+ */
 export type { AwsCredentialsProviderInit } from './aws-credentials-provider';
+/**
+ * @deprecated Use @vercel/oidc-aws-credentials-provider instead
+ * AWS authentication for Vercel Functions
+ */
 export { awsCredentialsProvider } from './aws-credentials-provider';
-export { getVercelOidcToken, getVercelOidcTokenSync, } from './get-vercel-oidc-token';
+/**
+ * @deprecated Use @vercel/oidc instead
+ * OIDC authentication for Vercel Functions
+ */
+export { getVercelOidcToken, getVercelOidcTokenSync } from '@vercel/oidc';

package/oidc/index.js

@@ -19,12 +19,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var oidc_exports = {};
 __export(oidc_exports, {
   awsCredentialsProvider: () => import_aws_credentials_provider.awsCredentialsProvider,
-  getVercelOidcToken: () => import_get_vercel_oidc_token.getVercelOidcToken,
-  getVercelOidcTokenSync: () => import_get_vercel_oidc_token.getVercelOidcTokenSync
+  getVercelOidcToken: () => import_oidc.getVercelOidcToken,
+  getVercelOidcTokenSync: () => import_oidc.getVercelOidcTokenSync
 });
 module.exports = __toCommonJS(oidc_exports);
 var import_aws_credentials_provider = require("./aws-credentials-provider");
-var import_get_vercel_oidc_token = require("./get-vercel-oidc-token");
+var import_oidc = require("@vercel/oidc");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   awsCredentialsProvider,

package/package.json

@@ -21,12 +21,16 @@
       "import": "./oidc/index.js",
       "require": "./oidc/index.js"
     },
+    "./db-connections": {
+      "import": "./db-connections/index.js",
+      "require": "./db-connections/index.js"
+    },
     "./middleware": {
       "import": "./middleware.js",
       "require": "./middleware.js"
     }
   },
-  "version": "2.2.4",
+  "version": "2.2.6",
   "repository": {
     "directory": "packages/functions",
     "type": "git",
@@ -39,6 +43,12 @@
     "@aws-sdk/client-s3": "3.609.0",
     "@aws-sdk/credential-provider-web-identity": "3.609.0",
     "@smithy/types": "3.3.0",
+    "@types/pg": "8.15.5",
+    "cassandra-driver": "4.8.0",
+    "ioredis": "5.6.1",
+    "mariadb": "3.4.5",
+    "mongodb": "6.18.0",
+    "mysql2": "3.14.2",
     "tinyspawn": "1.3.1",
     "typedoc": "0.24.6",
     "typedoc-plugin-markdown": "4.1.2",
@@ -61,6 +71,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@vercel/oidc": "2.0.0"
+  },
   "scripts": {
     "pretest": "pnpm run build:code",
     "test": "vitest",

package/oidc/get-vercel-oidc-token.d.ts

@@ -1,43 +0,0 @@
-/**
- * Gets the current OIDC token from the request context or the environment variable.
- *
- * Do not cache this value, as it is subject to change in production!
- *
- * This function is used to retrieve the OIDC token from the request context or the environment variable.
- * It checks for the `x-vercel-oidc-token` header in the request context and falls back to the `VERCEL_OIDC_TOKEN` environment variable if the header is not present.
- *
- * @returns {Promise<string>} A promise that resolves to the OIDC token.
- * @throws {Error} If the `x-vercel-oidc-token` header is missing from the request context and the environment variable `VERCEL_OIDC_TOKEN` is not set.
- *
- * @example
- *
- * ```js
- * // Using the OIDC token
- * getVercelOidcToken().then((token) => {
- *   console.log('OIDC Token:', token);
- * }).catch((error) => {
- *   console.error('Error:', error.message);
- * });
- * ```
- */
-export declare function getVercelOidcToken(): Promise<string>;
-/**
- * Gets the current OIDC token from the request context or the environment variable.
- *
- * Do not cache this value, as it is subject to change in production!
- *
- * This function is used to retrieve the OIDC token from the request context or the environment variable.
- * It checks for the `x-vercel-oidc-token` header in the request context and falls back to the `VERCEL_OIDC_TOKEN` environment variable if the header is not present.
- *
- * @returns {string} The OIDC token.
- * @throws {Error} If the `x-vercel-oidc-token` header is missing from the request context and the environment variable `VERCEL_OIDC_TOKEN` is not set.
- *
- * @example
- *
- * ```js
- * // Using the OIDC token
- * const token = getVercelOidcTokenSync();
- * console.log('OIDC Token:', token);
- * ```
- */
-export declare function getVercelOidcTokenSync(): string;