@vercel/functions 2.2.5 → 2.2.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @vercel/functions
 
+## 2.2.7
+
+### Patch Changes
+
+- Make DB pool inert in local dev ([#13647](https://github.com/vercel/vercel/pull/13647))
+
+## 2.2.6
+
+### Patch Changes
+
+- Introduce attachDatabasePool function ([#13632](https://github.com/vercel/vercel/pull/13632))
+
 ## 2.2.5
 
 ### 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,148 @@
+"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 (!process.env.VERCEL_URL) {
+    return;
+  }
+  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/db-connections/type-assertion.js

@@ -0,0 +1,44 @@
+"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 type_assertion_exports = {};
+__export(type_assertion_exports, {
+  cassandraSubtypeCheck: () => cassandraSubtypeCheck,
+  ioredisSubtypeCheck: () => ioredisSubtypeCheck,
+  mariadbSubtypeCheck: () => mariadbSubtypeCheck,
+  mongoSubtypeCheck: () => mongoSubtypeCheck,
+  mysql2SubtypeCheck: () => mysql2SubtypeCheck,
+  pgSubtypeCheck: () => pgSubtypeCheck
+});
+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 = {
+  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:221](https://github.com/vercel/vercel/blob/main/packages/functions/src/db-connections/index.ts#L221)
+
+---
+
 ### geolocation
 
 ▸ **geolocation**(`request`): [`Geo`](../interfaces/index.Geo.md)

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/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.5",
+  "version": "2.2.7",
   "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",