@prisma/query-plan-executor 6.17.0-dev.21 → 6.17.0-dev.23

package/dist/index.js

@@ -53639,8 +53639,8 @@ var require_lrucache = __commonJS({
         const deleted = this.delete(key);
         if (!deleted && value !== void 0) {
           if (this.map.size >= this.max) {
-            const firstKey = this.map.keys().next().value;
-            this.delete(firstKey);
+            const firstKey2 = this.map.keys().next().value;
+            this.delete(firstKey2);
           }
           this.map.set(key, value);
         }
@@ -108555,7 +108555,7 @@ function isPromiseLike(value) {
 }
 
 // package.json
-var version = "6.17.0-dev.21";
+var version = "6.17.0-dev.23";
 
 // src/utils/error.ts
 function extractErrorFromUnknown(value) {
@@ -109273,97 +109273,200 @@ function parseConnectionString(connectionString) {
     }
     config3.port = port;
   }
+  const parameters = {};
   for (const part of paramParts) {
     const [key, value] = part.split("=", 2);
     if (!key) continue;
     const trimmedKey = key.trim();
-    const trimmedValue = value.trim();
-    switch (trimmedKey) {
-      case "database":
-      case "initial catalog":
-        config3.database = trimmedValue;
-        break;
-      case "user":
-      case "username":
-      case "uid":
-      case "userid":
-        config3.user = trimmedValue;
-        break;
-      case "password":
-      case "pwd":
-        config3.password = trimmedValue;
-        break;
-      case "encrypt":
-        config3.options = config3.options || {};
-        config3.options.encrypt = trimmedValue.toLowerCase() === "true";
-        break;
-      case "trustServerCertificate":
-        config3.options = config3.options || {};
-        config3.options.trustServerCertificate = trimmedValue.toLowerCase() === "true";
-        break;
-      case "connectionLimit": {
-        config3.pool = config3.pool || {};
-        const limit = parseInt(trimmedValue, 10);
-        if (isNaN(limit)) {
-          throw new Error(`Invalid connection limit: ${trimmedValue}`);
-        }
-        config3.pool.max = limit;
-        break;
-      }
-      case "connectTimeout":
-      case "connectionTimeout": {
-        const connectTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(connectTimeout)) {
-          throw new Error(`Invalid connection timeout: ${trimmedValue}`);
-        }
-        config3.connectionTimeout = connectTimeout;
-        break;
-      }
-      case "loginTimeout": {
-        const loginTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(loginTimeout)) {
-          throw new Error(`Invalid login timeout: ${trimmedValue}`);
-        }
-        config3.connectionTimeout = loginTimeout;
-        break;
+    if (trimmedKey in parameters) {
+      throw new Error(`Duplication configuration parameter: ${trimmedKey}`);
+    }
+    parameters[trimmedKey] = value.trim();
+    if (!handledParameters.includes(trimmedKey)) {
+      debug5(`Unknown connection string parameter: ${trimmedKey}`);
+    }
+  }
+  const database = firstKey(parameters, "database", "initial catalog");
+  if (database !== null) {
+    config3.database = database;
+  }
+  const user = firstKey(parameters, "user", "username", "uid", "userid");
+  if (user !== null) {
+    config3.user = user;
+  }
+  const password = firstKey(parameters, "password", "pwd");
+  if (password !== null) {
+    config3.password = password;
+  }
+  const encrypt = firstKey(parameters, "encrypt");
+  if (encrypt !== null) {
+    config3.options = config3.options || {};
+    config3.options.encrypt = encrypt.toLowerCase() === "true";
+  }
+  const trustServerCertificate = firstKey(parameters, "trustServerCertificate");
+  if (trustServerCertificate !== null) {
+    config3.options = config3.options || {};
+    config3.options.trustServerCertificate = trustServerCertificate.toLowerCase() === "true";
+  }
+  const connectionLimit = firstKey(parameters, "connectionLimit");
+  if (connectionLimit !== null) {
+    config3.pool = config3.pool || {};
+    const limit = parseInt(connectionLimit, 10);
+    if (isNaN(limit)) {
+      throw new Error(`Invalid connection limit: ${connectionLimit}`);
+    }
+    config3.pool.max = limit;
+  }
+  const connectionTimeout = firstKey(parameters, "connectionTimeout", "connectTimeout");
+  if (connectionTimeout !== null) {
+    const timeout = parseInt(connectionTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid connection timeout: ${connectionTimeout}`);
+    }
+    config3.connectionTimeout = timeout;
+  }
+  const loginTimeout = firstKey(parameters, "loginTimeout");
+  if (loginTimeout !== null) {
+    const timeout = parseInt(loginTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid login timeout: ${loginTimeout}`);
+    }
+    config3.connectionTimeout = timeout;
+  }
+  const socketTimeout = firstKey(parameters, "socketTimeout");
+  if (socketTimeout !== null) {
+    const timeout = parseInt(socketTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid socket timeout: ${socketTimeout}`);
+    }
+    config3.requestTimeout = timeout;
+  }
+  const poolTimeout = firstKey(parameters, "poolTimeout");
+  if (poolTimeout !== null) {
+    const timeout = parseInt(poolTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid pool timeout: ${poolTimeout}`);
+    }
+    config3.pool = config3.pool || {};
+    config3.pool.acquireTimeoutMillis = timeout * 1e3;
+  }
+  const appName = firstKey(parameters, "applicationName", "application name");
+  if (appName !== null) {
+    config3.options = config3.options || {};
+    config3.options.appName = appName;
+  }
+  const isolationLevel = firstKey(parameters, "isolationLevel");
+  if (isolationLevel !== null) {
+    config3.options = config3.options || {};
+    config3.options.isolationLevel = mapIsolationLevelFromString(isolationLevel);
+  }
+  const authentication = firstKey(parameters, "authentication");
+  if (authentication !== null) {
+    config3.authentication = parseAuthenticationOptions(parameters, authentication);
+  }
+  if (!config3.server || config3.server.trim() === "") {
+    throw new Error("Server host is required in connection string");
+  }
+  return config3;
+}
+function parseAuthenticationOptions(parameters, authenticationValue) {
+  switch (authenticationValue) {
+    /**
+     * 'DefaultAzureCredential' is not listed in the JDBC driver spec
+     * https://learn.microsoft.com/en-us/sql/connect/jdbc/setting-the-connection-properties?view=sql-server-ver15#properties
+     * but is supported by tedious so included here
+     */
+    case "DefaultAzureCredential":
+    case "ActiveDirectoryIntegrated":
+    case "ActiveDirectoryInteractive":
+      return { type: "azure-active-directory-default", options: {} };
+    case "ActiveDirectoryPassword": {
+      const userName = firstKey(parameters, "userName");
+      const password = firstKey(parameters, "password");
+      const clientId = firstKey(parameters, "clientId");
+      const tenantId = firstKey(parameters, "tenantId");
+      if (!userName || !password || !clientId) {
+        throw new Error(`Invalid authentication, ActiveDirectoryPassword requires userName, password, clientId`);
       }
-      case "socketTimeout": {
-        const socketTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(socketTimeout)) {
-          throw new Error(`Invalid socket timeout: ${trimmedValue}`);
+      return {
+        type: "azure-active-directory-password",
+        options: {
+          userName,
+          password,
+          clientId,
+          tenantId: tenantId || ""
         }
-        config3.requestTimeout = socketTimeout;
-        break;
+      };
+    }
+    case "ActiveDirectoryManagedIdentity":
+    case "ActiveDirectoryMSI": {
+      const clientId = firstKey(parameters, "clientId");
+      const msiEndpoint = firstKey(parameters, "msiEndpoint");
+      const msiSecret = firstKey(parameters, "msiSecret");
+      if (!msiEndpoint || !msiSecret) {
+        throw new Error(`Invalid authentication, ActiveDirectoryManagedIdentity requires msiEndpoint, msiSecret`);
       }
-      case "poolTimeout": {
-        const poolTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(poolTimeout)) {
-          throw new Error(`Invalid pool timeout: ${trimmedValue}`);
+      return {
+        type: "azure-active-directory-msi-app-service",
+        options: {
+          clientId: clientId || void 0,
+          // @ts-expect-error TODO: tedious typings don't define msiEndpoint and msiSecret -- needs to be fixed upstream
+          msiEndpoint,
+          msiSecret
         }
-        config3.pool = config3.pool || {};
-        config3.pool.acquireTimeoutMillis = poolTimeout * 1e3;
-        break;
+      };
+    }
+    case "ActiveDirectoryServicePrincipal": {
+      const clientId = firstKey(parameters, "userName");
+      const clientSecret = firstKey(parameters, "password");
+      const tenantId = firstKey(parameters, "tenantId");
+      if (clientId && clientSecret) {
+        return {
+          type: "azure-active-directory-service-principal-secret",
+          options: {
+            clientId,
+            clientSecret,
+            tenantId: tenantId || ""
+          }
+        };
+      } else {
+        throw new Error(
+          `Invalid authentication, ActiveDirectoryServicePrincipal requires userName (clientId), password (clientSecret)`
+        );
       }
-      case "applicationName":
-      case "application name":
-        config3.options = config3.options || {};
-        config3.options.appName = trimmedValue;
-        break;
-      case "isolationLevel":
-        config3.options = config3.options || {};
-        config3.options.isolationLevel = mapIsolationLevelFromString(trimmedValue);
-        break;
-      case "schema":
-        break;
-      default:
-        debug5(`Unknown connection string parameter: ${trimmedKey}`);
     }
   }
-  if (!config3.server || config3.server.trim() === "") {
-    throw new Error("Server host is required in connection string");
+  return void 0;
+}
+function firstKey(parameters, ...keys) {
+  for (const key of keys) {
+    if (key in parameters) {
+      return parameters[key];
+    }
   }
-  return config3;
+  return null;
 }
+var handledParameters = [
+  "application name",
+  "applicationName",
+  "connectTimeout",
+  "connectionLimit",
+  "connectionTimeout",
+  "database",
+  "encrypt",
+  "initial catalog",
+  "isolationLevel",
+  "loginTimeout",
+  "password",
+  "poolTimeout",
+  "pwd",
+  "socketTimeout",
+  "trustServerCertificate",
+  "uid",
+  "user",
+  "userid",
+  "username"
+];
 function mapColumnType2(col) {
   switch (col.type) {
     case import_mssql3.default.VarChar:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/query-plan-executor",
-  "version": "6.17.0-dev.21",
+  "version": "6.17.0-dev.23",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,11 +20,11 @@
     "temporal-polyfill": "0.3.0",
     "vitest": "3.2.4",
     "zod": "4.1.3",
-    "@prisma/adapter-pg": "6.17.0-dev.21",
-    "@prisma/adapter-mariadb": "6.17.0-dev.21",
-    "@prisma/adapter-mssql": "6.17.0-dev.21",
-    "@prisma/driver-adapter-utils": "6.17.0-dev.21",
-    "@prisma/client-engine-runtime": "6.17.0-dev.21"
+    "@prisma/adapter-pg": "6.17.0-dev.23",
+    "@prisma/adapter-mariadb": "6.17.0-dev.23",
+    "@prisma/client-engine-runtime": "6.17.0-dev.23",
+    "@prisma/adapter-mssql": "6.17.0-dev.23",
+    "@prisma/driver-adapter-utils": "6.17.0-dev.23"
   },
   "files": [
     "dist"