npm - @prisma/adapter-mssql - Versions diffs - 6.15.0-dev.3 → 6.15.0-dev.30 - Mend

@prisma/adapter-mssql 6.15.0-dev.3 → 6.15.0-dev.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.d.mts CHANGED Viewed

@@ -26,11 +26,10 @@ declare class MssqlQueryable implements SqlQueryable {
 }
 export declare class PrismaMssql implements SqlDriverAdapterFactory {
-    private readonly config;
-    private readonly options?;
+    #private;
     readonly provider = "sqlserver";
     readonly adapterName: string;
-    constructor(config: sql.config, options?: PrismaMssqlOptions | undefined);
+    constructor(configOrString: sql.config | string, options?: PrismaMssqlOptions);
     connect(): Promise<PrismaMssqlAdapter>;
 }
@@ -47,6 +46,8 @@ declare class PrismaMssqlAdapter extends MssqlQueryable implements SqlDriverAdap
 declare type PrismaMssqlOptions = {
     schema?: string;
+    onPoolError?: (err: unknown) => void;
+    onConnectionError?: (err: unknown) => void;
 };
 export { }

package/dist/index.d.ts CHANGED Viewed

@@ -26,11 +26,10 @@ declare class MssqlQueryable implements SqlQueryable {
 }
 export declare class PrismaMssql implements SqlDriverAdapterFactory {
-    private readonly config;
-    private readonly options?;
+    #private;
     readonly provider = "sqlserver";
     readonly adapterName: string;
-    constructor(config: sql.config, options?: PrismaMssqlOptions | undefined);
+    constructor(configOrString: sql.config | string, options?: PrismaMssqlOptions);
     connect(): Promise<PrismaMssqlAdapter>;
 }
@@ -47,6 +46,8 @@ declare class PrismaMssqlAdapter extends MssqlQueryable implements SqlDriverAdap
 declare type PrismaMssqlOptions = {
     schema?: string;
+    onPoolError?: (err: unknown) => void;
+    onConnectionError?: (err: unknown) => void;
 };
 export { }

package/dist/index.js CHANGED Viewed

@@ -35,60 +35,201 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 // src/mssql.ts
-var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
+var import_driver_adapter_utils3 = require("@prisma/driver-adapter-utils");
 var import_async_mutex = require("async-mutex");
-var import_mssql2 = __toESM(require("mssql"));
+var import_mssql3 = __toESM(require("mssql"));
 // package.json
 var name = "@prisma/adapter-mssql";
-// src/conversion.ts
+// src/connection-string.ts
 var import_driver_adapter_utils = require("@prisma/driver-adapter-utils");
 var import_mssql = __toESM(require("mssql"));
+function mapIsolationLevelFromString(level) {
+  const normalizedLevel = level.toUpperCase().replace(/\s+/g, "");
+  switch (normalizedLevel) {
+    case "READCOMMITTED":
+      return import_mssql.default.ISOLATION_LEVEL.READ_COMMITTED;
+    case "READUNCOMMITTED":
+      return import_mssql.default.ISOLATION_LEVEL.READ_UNCOMMITTED;
+    case "REPEATABLEREAD":
+      return import_mssql.default.ISOLATION_LEVEL.REPEATABLE_READ;
+    case "SERIALIZABLE":
+      return import_mssql.default.ISOLATION_LEVEL.SERIALIZABLE;
+    case "SNAPSHOT":
+      return import_mssql.default.ISOLATION_LEVEL.SNAPSHOT;
+    default:
+      throw new Error(`Invalid isolation level: ${level}`);
+  }
+}
+var debug = (0, import_driver_adapter_utils.Debug)("prisma:driver-adapter:mssql:connection-string");
+function extractSchemaFromConnectionString(connectionString) {
+  const withoutProtocol = connectionString.replace(/^sqlserver:\/\//, "");
+  const parts = withoutProtocol.split(";");
+  for (const part of parts) {
+    const [key, value] = part.split("=", 2);
+    if (key?.trim() === "schema") {
+      return value?.trim();
+    }
+  }
+  return void 0;
+}
+function parseConnectionString(connectionString) {
+  const withoutProtocol = connectionString.replace(/^sqlserver:\/\//, "");
+  const [hostPart, ...paramParts] = withoutProtocol.split(";");
+  const config = {
+    server: "",
+    options: {},
+    pool: {}
+  };
+  const [host, portStr] = hostPart.split(":");
+  config.server = host.trim();
+  if (portStr) {
+    const port = parseInt(portStr, 10);
+    if (isNaN(port)) {
+      throw new Error(`Invalid port number: ${portStr}`);
+    }
+    config.port = port;
+  }
+  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":
+        config.database = trimmedValue;
+        break;
+      case "user":
+      case "username":
+      case "uid":
+      case "userid":
+        config.user = trimmedValue;
+        break;
+      case "password":
+      case "pwd":
+        config.password = trimmedValue;
+        break;
+      case "encrypt":
+        config.options = config.options || {};
+        config.options.encrypt = trimmedValue.toLowerCase() === "true";
+        break;
+      case "trustServerCertificate":
+        config.options = config.options || {};
+        config.options.trustServerCertificate = trimmedValue.toLowerCase() === "true";
+        break;
+      case "connectionLimit": {
+        config.pool = config.pool || {};
+        const limit = parseInt(trimmedValue, 10);
+        if (isNaN(limit)) {
+          throw new Error(`Invalid connection limit: ${trimmedValue}`);
+        }
+        config.pool.max = limit;
+        break;
+      }
+      case "connectTimeout":
+      case "connectionTimeout": {
+        const connectTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(connectTimeout)) {
+          throw new Error(`Invalid connection timeout: ${trimmedValue}`);
+        }
+        config.connectionTimeout = connectTimeout;
+        break;
+      }
+      case "loginTimeout": {
+        const loginTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(loginTimeout)) {
+          throw new Error(`Invalid login timeout: ${trimmedValue}`);
+        }
+        config.connectionTimeout = loginTimeout;
+        break;
+      }
+      case "socketTimeout": {
+        const socketTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(socketTimeout)) {
+          throw new Error(`Invalid socket timeout: ${trimmedValue}`);
+        }
+        config.requestTimeout = socketTimeout;
+        break;
+      }
+      case "poolTimeout": {
+        const poolTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(poolTimeout)) {
+          throw new Error(`Invalid pool timeout: ${trimmedValue}`);
+        }
+        config.pool = config.pool || {};
+        config.pool.acquireTimeoutMillis = poolTimeout * 1e3;
+        break;
+      }
+      case "applicationName":
+      case "application name":
+        config.options = config.options || {};
+        config.options.appName = trimmedValue;
+        break;
+      case "isolationLevel":
+        config.options = config.options || {};
+        config.options.isolationLevel = mapIsolationLevelFromString(trimmedValue);
+        break;
+      case "schema":
+        break;
+      default:
+        debug(`Unknown connection string parameter: ${trimmedKey}`);
+    }
+  }
+  if (!config.server || config.server.trim() === "") {
+    throw new Error("Server host is required in connection string");
+  }
+  return config;
+}
+// src/conversion.ts
+var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
+var import_mssql2 = __toESM(require("mssql"));
 function mapColumnType(col) {
   switch (col.type) {
-    case import_mssql.default.VarChar:
-    case import_mssql.default.Char:
-    case import_mssql.default.NVarChar:
-    case import_mssql.default.NChar:
-    case import_mssql.default.Text:
-    case import_mssql.default.NText:
-    case import_mssql.default.Xml:
-      return import_driver_adapter_utils.ColumnTypeEnum.Text;
-    case import_mssql.default.Bit:
-      return import_driver_adapter_utils.ColumnTypeEnum.Boolean;
-    case import_mssql.default.TinyInt:
-    case import_mssql.default.SmallInt:
-    case import_mssql.default.Int:
-      return import_driver_adapter_utils.ColumnTypeEnum.Int32;
-    case import_mssql.default.BigInt:
-      return import_driver_adapter_utils.ColumnTypeEnum.Int64;
-    case import_mssql.default.DateTime2:
-    case import_mssql.default.SmallDateTime:
-    case import_mssql.default.DateTime:
-    case import_mssql.default.DateTimeOffset:
-      return import_driver_adapter_utils.ColumnTypeEnum.DateTime;
-    case import_mssql.default.Real:
-      return import_driver_adapter_utils.ColumnTypeEnum.Float;
-    case import_mssql.default.Float:
-    case import_mssql.default.Money:
-    case import_mssql.default.SmallMoney:
-      return import_driver_adapter_utils.ColumnTypeEnum.Double;
-    case import_mssql.default.UniqueIdentifier:
-      return import_driver_adapter_utils.ColumnTypeEnum.Uuid;
-    case import_mssql.default.Decimal:
-    case import_mssql.default.Numeric:
-      return import_driver_adapter_utils.ColumnTypeEnum.Numeric;
-    case import_mssql.default.Date:
-      return import_driver_adapter_utils.ColumnTypeEnum.Date;
-    case import_mssql.default.Time:
-      return import_driver_adapter_utils.ColumnTypeEnum.Time;
-    case import_mssql.default.VarBinary:
-    case import_mssql.default.Binary:
-    case import_mssql.default.Image:
-      return import_driver_adapter_utils.ColumnTypeEnum.Bytes;
+    case import_mssql2.default.VarChar:
+    case import_mssql2.default.Char:
+    case import_mssql2.default.NVarChar:
+    case import_mssql2.default.NChar:
+    case import_mssql2.default.Text:
+    case import_mssql2.default.NText:
+    case import_mssql2.default.Xml:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Text;
+    case import_mssql2.default.Bit:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Boolean;
+    case import_mssql2.default.TinyInt:
+    case import_mssql2.default.SmallInt:
+    case import_mssql2.default.Int:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Int32;
+    case import_mssql2.default.BigInt:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Int64;
+    case import_mssql2.default.DateTime2:
+    case import_mssql2.default.SmallDateTime:
+    case import_mssql2.default.DateTime:
+    case import_mssql2.default.DateTimeOffset:
+      return import_driver_adapter_utils2.ColumnTypeEnum.DateTime;
+    case import_mssql2.default.Real:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Float;
+    case import_mssql2.default.Float:
+    case import_mssql2.default.Money:
+    case import_mssql2.default.SmallMoney:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Double;
+    case import_mssql2.default.UniqueIdentifier:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Uuid;
+    case import_mssql2.default.Decimal:
+    case import_mssql2.default.Numeric:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Numeric;
+    case import_mssql2.default.Date:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Date;
+    case import_mssql2.default.Time:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Time;
+    case import_mssql2.default.VarBinary:
+    case import_mssql2.default.Binary:
+    case import_mssql2.default.Image:
+      return import_driver_adapter_utils2.ColumnTypeEnum.Bytes;
     default:
-      throw new import_driver_adapter_utils.DriverAdapterError({
+      throw new import_driver_adapter_utils2.DriverAdapterError({
         kind: "UnsupportedNativeDataType",
         type: col["udt"]?.name ?? "N/A"
       });
@@ -97,25 +238,28 @@ function mapColumnType(col) {
 function mapIsolationLevel(level) {
   switch (level) {
     case "READ COMMITTED":
-      return import_mssql.default.ISOLATION_LEVEL.READ_COMMITTED;
+      return import_mssql2.default.ISOLATION_LEVEL.READ_COMMITTED;
     case "READ UNCOMMITTED":
-      return import_mssql.default.ISOLATION_LEVEL.READ_UNCOMMITTED;
+      return import_mssql2.default.ISOLATION_LEVEL.READ_UNCOMMITTED;
     case "REPEATABLE READ":
-      return import_mssql.default.ISOLATION_LEVEL.REPEATABLE_READ;
+      return import_mssql2.default.ISOLATION_LEVEL.REPEATABLE_READ;
     case "SERIALIZABLE":
-      return import_mssql.default.ISOLATION_LEVEL.SERIALIZABLE;
+      return import_mssql2.default.ISOLATION_LEVEL.SERIALIZABLE;
     case "SNAPSHOT":
-      return import_mssql.default.ISOLATION_LEVEL.SNAPSHOT;
+      return import_mssql2.default.ISOLATION_LEVEL.SNAPSHOT;
     default:
-      throw new import_driver_adapter_utils.DriverAdapterError({
+      throw new import_driver_adapter_utils2.DriverAdapterError({
         kind: "InvalidIsolationLevel",
         level
       });
   }
 }
-function mapArg(arg) {
-  if (arg instanceof Uint8Array) {
-    return Buffer.from(arg);
+function mapArg(arg, argType) {
+  if (arg === null) {
+    return null;
+  }
+  if (typeof arg === "string" && argType.scalarType === "bigint") {
+    arg = BigInt(arg);
   }
   if (typeof arg === "bigint") {
     if (arg >= BigInt(Number.MIN_SAFE_INTEGER) && arg <= BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -123,28 +267,74 @@ function mapArg(arg) {
     }
     return arg.toString();
   }
+  if (typeof arg === "string" && argType.scalarType === "datetime") {
+    arg = new Date(arg);
+  }
+  if (arg instanceof Date) {
+    switch (argType.dbType) {
+      case "TIME":
+        return formatTime(arg);
+      case "DATE":
+        return formatDate(arg);
+      default:
+        return formatDateTime(arg);
+    }
+  }
+  if (typeof arg === "string" && argType.scalarType === "bytes") {
+    return Buffer.from(arg, "base64");
+  }
+  if (Array.isArray(arg) && argType.scalarType === "bytes") {
+    return Buffer.from(arg);
+  }
+  if (ArrayBuffer.isView(arg)) {
+    return Buffer.from(arg.buffer, arg.byteOffset, arg.byteLength);
+  }
   return arg;
 }
 function mapRow(row, columns) {
   return row.map((value, i) => {
+    const type = columns?.[i]?.type;
     if (value instanceof Date) {
-      if (columns?.[i]?.type === import_mssql.default.Time) {
-        return value.toISOString().split("T").at(1)?.replace("Z", "");
+      if (type === import_mssql2.default.Time) {
+        return value.toISOString().split("T")[1].replace("Z", "");
       }
       return value.toISOString();
     }
+    if (typeof value === "number" && type === import_mssql2.default.Real) {
+      for (let digits = 7; digits <= 9; digits++) {
+        const parsed = Number.parseFloat(value.toPrecision(digits));
+        if (value === new Float32Array([parsed])[0]) {
+          return parsed;
+        }
+      }
+      return value;
+    }
     if (Buffer.isBuffer(value)) {
       return Array.from(value);
     }
-    if (typeof value === "string" && columns?.[i].type === import_mssql.default.UniqueIdentifier) {
+    if (typeof value === "string" && type === import_mssql2.default.UniqueIdentifier) {
       return value.toLowerCase();
     }
-    if (typeof value === "boolean" && columns?.[i]?.type === import_mssql.default.Bit) {
+    if (typeof value === "boolean" && type === import_mssql2.default.Bit) {
       return value ? 1 : 0;
     }
     return value;
   });
 }
+function formatDateTime(date) {
+  const pad = (n, z = 2) => String(n).padStart(z, "0");
+  const ms = date.getUTCMilliseconds();
+  return date.getUTCFullYear() + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate()) + " " + pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + (ms ? "." + String(ms).padStart(3, "0") : "");
+}
+function formatDate(date) {
+  const pad = (n, z = 2) => String(n).padStart(z, "0");
+  return date.getUTCFullYear() + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate());
+}
+function formatTime(date) {
+  const pad = (n, z = 2) => String(n).padStart(z, "0");
+  const ms = date.getUTCMilliseconds();
+  return pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + (ms ? "." + String(ms).padStart(3, "0") : "");
+}
 // src/errors.ts
 function convertDriverError(error) {
@@ -331,7 +521,7 @@ function isDriverError(error) {
 }
 // src/mssql.ts
-var debug = (0, import_driver_adapter_utils2.Debug)("prisma:driver-adapter:mssql");
+var debug2 = (0, import_driver_adapter_utils3.Debug)("prisma:driver-adapter:mssql");
 var MssqlQueryable = class {
   constructor(conn) {
     this.conn = conn;
@@ -340,7 +530,7 @@ var MssqlQueryable = class {
   adapterName = name;
   async queryRaw(query) {
     const tag = "[js::query_raw]";
-    debug(`${tag} %O`, query);
+    debug2(`${tag} %O`, query);
     const { recordset, columns: columnsList } = await this.performIO(query);
     const columns = columnsList?.[0];
     return {
@@ -351,7 +541,7 @@ var MssqlQueryable = class {
   }
   async executeRaw(query) {
     const tag = "[js::execute_raw]";
-    debug(`${tag} %O`, query);
+    debug2(`${tag} %O`, query);
     return (await this.performIO(query)).rowsAffected?.[0] ?? 0;
   }
   async performIO(query) {
@@ -359,7 +549,7 @@ var MssqlQueryable = class {
       const req = this.conn.request();
       req.arrayRowMode = true;
       for (let i = 0; i < query.args.length; i++) {
-        req.input(`P${i + 1}`, mapArg(query.args[i]));
+        req.input(`P${i + 1}`, mapArg(query.args[i], query.argTypes[i]));
       }
       const res = await req.query(query.sql);
       return res;
@@ -368,8 +558,8 @@ var MssqlQueryable = class {
     }
   }
   onError(error) {
-    debug("Error in performIO: %O", error);
-    throw new import_driver_adapter_utils2.DriverAdapterError(convertDriverError(error));
+    debug2("Error in performIO: %O", error);
+    throw new import_driver_adapter_utils3.DriverAdapterError(convertDriverError(error));
   }
 };
 var MssqlTransaction = class extends MssqlQueryable {
@@ -390,14 +580,14 @@ var MssqlTransaction = class extends MssqlQueryable {
     }
   }
   async commit() {
-    debug(`[js::commit]`);
+    debug2(`[js::commit]`);
     await this.transaction.commit();
   }
   async rollback() {
-    debug(`[js::rollback]`);
+    debug2(`[js::rollback]`);
     await this.transaction.rollback().catch((e) => {
       if (e.code === "EABORT") {
-        debug(`[js::rollback] Transaction already aborted`);
+        debug2(`[js::rollback] Transaction already aborted`);
         return;
       }
       throw e;
@@ -418,8 +608,12 @@ var PrismaMssqlAdapter = class extends MssqlQueryable {
       usePhantomQuery: true
     };
     const tag = "[js::startTransaction]";
-    debug("%s options: %O", tag, options);
+    debug2("%s options: %O", tag, options);
     const tx = this.pool.transaction();
+    tx.on("error", (err) => {
+      debug2("Error from pool connection: %O", err);
+      this.options?.onConnectionError?.(err);
+    });
     try {
       await tx.begin(isolationLevel !== void 0 ? mapIsolationLevel(isolationLevel) : void 0);
       return new MssqlTransaction(tx, options);
@@ -442,16 +636,31 @@ var PrismaMssqlAdapter = class extends MssqlQueryable {
   }
 };
 var PrismaMssqlAdapterFactory = class {
-  constructor(config, options) {
-    this.config = config;
-    this.options = options;
-  }
   provider = "sqlserver";
   adapterName = name;
+  #config;
+  #options;
+  constructor(configOrString, options) {
+    if (typeof configOrString === "string") {
+      this.#config = parseConnectionString(configOrString);
+      const extractedSchema = extractSchemaFromConnectionString(configOrString);
+      this.#options = {
+        ...options,
+        schema: options?.schema ?? extractedSchema
+      };
+    } else {
+      this.#config = configOrString;
+      this.#options = options ?? {};
+    }
+  }
   async connect() {
-    const pool = new import_mssql2.default.ConnectionPool(this.config);
+    const pool = new import_mssql3.default.ConnectionPool(this.#config);
+    pool.on("error", (err) => {
+      debug2("Error from pool client: %O", err);
+      this.#options?.onPoolError?.(err);
+    });
     await pool.connect();
-    return new PrismaMssqlAdapter(pool, this.options);
+    return new PrismaMssqlAdapter(pool, this.#options);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.mjs CHANGED Viewed

@@ -1,58 +1,202 @@
 // src/mssql.ts
 import {
-  Debug,
+  Debug as Debug2,
   DriverAdapterError as DriverAdapterError2
 } from "@prisma/driver-adapter-utils";
 import { Mutex } from "async-mutex";
-import sql2 from "mssql";
+import sql3 from "mssql";
 // package.json
 var name = "@prisma/adapter-mssql";
-// src/conversion.ts
-import { ColumnTypeEnum, DriverAdapterError } from "@prisma/driver-adapter-utils";
+// src/connection-string.ts
+import { Debug } from "@prisma/driver-adapter-utils";
 import sql from "mssql";
+function mapIsolationLevelFromString(level) {
+  const normalizedLevel = level.toUpperCase().replace(/\s+/g, "");
+  switch (normalizedLevel) {
+    case "READCOMMITTED":
+      return sql.ISOLATION_LEVEL.READ_COMMITTED;
+    case "READUNCOMMITTED":
+      return sql.ISOLATION_LEVEL.READ_UNCOMMITTED;
+    case "REPEATABLEREAD":
+      return sql.ISOLATION_LEVEL.REPEATABLE_READ;
+    case "SERIALIZABLE":
+      return sql.ISOLATION_LEVEL.SERIALIZABLE;
+    case "SNAPSHOT":
+      return sql.ISOLATION_LEVEL.SNAPSHOT;
+    default:
+      throw new Error(`Invalid isolation level: ${level}`);
+  }
+}
+var debug = Debug("prisma:driver-adapter:mssql:connection-string");
+function extractSchemaFromConnectionString(connectionString) {
+  const withoutProtocol = connectionString.replace(/^sqlserver:\/\//, "");
+  const parts = withoutProtocol.split(";");
+  for (const part of parts) {
+    const [key, value] = part.split("=", 2);
+    if (key?.trim() === "schema") {
+      return value?.trim();
+    }
+  }
+  return void 0;
+}
+function parseConnectionString(connectionString) {
+  const withoutProtocol = connectionString.replace(/^sqlserver:\/\//, "");
+  const [hostPart, ...paramParts] = withoutProtocol.split(";");
+  const config = {
+    server: "",
+    options: {},
+    pool: {}
+  };
+  const [host, portStr] = hostPart.split(":");
+  config.server = host.trim();
+  if (portStr) {
+    const port = parseInt(portStr, 10);
+    if (isNaN(port)) {
+      throw new Error(`Invalid port number: ${portStr}`);
+    }
+    config.port = port;
+  }
+  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":
+        config.database = trimmedValue;
+        break;
+      case "user":
+      case "username":
+      case "uid":
+      case "userid":
+        config.user = trimmedValue;
+        break;
+      case "password":
+      case "pwd":
+        config.password = trimmedValue;
+        break;
+      case "encrypt":
+        config.options = config.options || {};
+        config.options.encrypt = trimmedValue.toLowerCase() === "true";
+        break;
+      case "trustServerCertificate":
+        config.options = config.options || {};
+        config.options.trustServerCertificate = trimmedValue.toLowerCase() === "true";
+        break;
+      case "connectionLimit": {
+        config.pool = config.pool || {};
+        const limit = parseInt(trimmedValue, 10);
+        if (isNaN(limit)) {
+          throw new Error(`Invalid connection limit: ${trimmedValue}`);
+        }
+        config.pool.max = limit;
+        break;
+      }
+      case "connectTimeout":
+      case "connectionTimeout": {
+        const connectTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(connectTimeout)) {
+          throw new Error(`Invalid connection timeout: ${trimmedValue}`);
+        }
+        config.connectionTimeout = connectTimeout;
+        break;
+      }
+      case "loginTimeout": {
+        const loginTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(loginTimeout)) {
+          throw new Error(`Invalid login timeout: ${trimmedValue}`);
+        }
+        config.connectionTimeout = loginTimeout;
+        break;
+      }
+      case "socketTimeout": {
+        const socketTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(socketTimeout)) {
+          throw new Error(`Invalid socket timeout: ${trimmedValue}`);
+        }
+        config.requestTimeout = socketTimeout;
+        break;
+      }
+      case "poolTimeout": {
+        const poolTimeout = parseInt(trimmedValue, 10);
+        if (isNaN(poolTimeout)) {
+          throw new Error(`Invalid pool timeout: ${trimmedValue}`);
+        }
+        config.pool = config.pool || {};
+        config.pool.acquireTimeoutMillis = poolTimeout * 1e3;
+        break;
+      }
+      case "applicationName":
+      case "application name":
+        config.options = config.options || {};
+        config.options.appName = trimmedValue;
+        break;
+      case "isolationLevel":
+        config.options = config.options || {};
+        config.options.isolationLevel = mapIsolationLevelFromString(trimmedValue);
+        break;
+      case "schema":
+        break;
+      default:
+        debug(`Unknown connection string parameter: ${trimmedKey}`);
+    }
+  }
+  if (!config.server || config.server.trim() === "") {
+    throw new Error("Server host is required in connection string");
+  }
+  return config;
+}
+// src/conversion.ts
+import {
+  ColumnTypeEnum,
+  DriverAdapterError
+} from "@prisma/driver-adapter-utils";
+import sql2 from "mssql";
 function mapColumnType(col) {
   switch (col.type) {
-    case sql.VarChar:
-    case sql.Char:
-    case sql.NVarChar:
-    case sql.NChar:
-    case sql.Text:
-    case sql.NText:
-    case sql.Xml:
+    case sql2.VarChar:
+    case sql2.Char:
+    case sql2.NVarChar:
+    case sql2.NChar:
+    case sql2.Text:
+    case sql2.NText:
+    case sql2.Xml:
       return ColumnTypeEnum.Text;
-    case sql.Bit:
+    case sql2.Bit:
       return ColumnTypeEnum.Boolean;
-    case sql.TinyInt:
-    case sql.SmallInt:
-    case sql.Int:
+    case sql2.TinyInt:
+    case sql2.SmallInt:
+    case sql2.Int:
       return ColumnTypeEnum.Int32;
-    case sql.BigInt:
+    case sql2.BigInt:
       return ColumnTypeEnum.Int64;
-    case sql.DateTime2:
-    case sql.SmallDateTime:
-    case sql.DateTime:
-    case sql.DateTimeOffset:
+    case sql2.DateTime2:
+    case sql2.SmallDateTime:
+    case sql2.DateTime:
+    case sql2.DateTimeOffset:
       return ColumnTypeEnum.DateTime;
-    case sql.Real:
+    case sql2.Real:
       return ColumnTypeEnum.Float;
-    case sql.Float:
-    case sql.Money:
-    case sql.SmallMoney:
+    case sql2.Float:
+    case sql2.Money:
+    case sql2.SmallMoney:
       return ColumnTypeEnum.Double;
-    case sql.UniqueIdentifier:
+    case sql2.UniqueIdentifier:
       return ColumnTypeEnum.Uuid;
-    case sql.Decimal:
-    case sql.Numeric:
+    case sql2.Decimal:
+    case sql2.Numeric:
       return ColumnTypeEnum.Numeric;
-    case sql.Date:
+    case sql2.Date:
       return ColumnTypeEnum.Date;
-    case sql.Time:
+    case sql2.Time:
       return ColumnTypeEnum.Time;
-    case sql.VarBinary:
-    case sql.Binary:
-    case sql.Image:
+    case sql2.VarBinary:
+    case sql2.Binary:
+    case sql2.Image:
       return ColumnTypeEnum.Bytes;
     default:
       throw new DriverAdapterError({
@@ -64,15 +208,15 @@ function mapColumnType(col) {
 function mapIsolationLevel(level) {
   switch (level) {
     case "READ COMMITTED":
-      return sql.ISOLATION_LEVEL.READ_COMMITTED;
+      return sql2.ISOLATION_LEVEL.READ_COMMITTED;
     case "READ UNCOMMITTED":
-      return sql.ISOLATION_LEVEL.READ_UNCOMMITTED;
+      return sql2.ISOLATION_LEVEL.READ_UNCOMMITTED;
     case "REPEATABLE READ":
-      return sql.ISOLATION_LEVEL.REPEATABLE_READ;
+      return sql2.ISOLATION_LEVEL.REPEATABLE_READ;
     case "SERIALIZABLE":
-      return sql.ISOLATION_LEVEL.SERIALIZABLE;
+      return sql2.ISOLATION_LEVEL.SERIALIZABLE;
     case "SNAPSHOT":
-      return sql.ISOLATION_LEVEL.SNAPSHOT;
+      return sql2.ISOLATION_LEVEL.SNAPSHOT;
     default:
       throw new DriverAdapterError({
         kind: "InvalidIsolationLevel",
@@ -80,9 +224,12 @@ function mapIsolationLevel(level) {
       });
   }
 }
-function mapArg(arg) {
-  if (arg instanceof Uint8Array) {
-    return Buffer.from(arg);
+function mapArg(arg, argType) {
+  if (arg === null) {
+    return null;
+  }
+  if (typeof arg === "string" && argType.scalarType === "bigint") {
+    arg = BigInt(arg);
   }
   if (typeof arg === "bigint") {
     if (arg >= BigInt(Number.MIN_SAFE_INTEGER) && arg <= BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -90,28 +237,74 @@ function mapArg(arg) {
     }
     return arg.toString();
   }
+  if (typeof arg === "string" && argType.scalarType === "datetime") {
+    arg = new Date(arg);
+  }
+  if (arg instanceof Date) {
+    switch (argType.dbType) {
+      case "TIME":
+        return formatTime(arg);
+      case "DATE":
+        return formatDate(arg);
+      default:
+        return formatDateTime(arg);
+    }
+  }
+  if (typeof arg === "string" && argType.scalarType === "bytes") {
+    return Buffer.from(arg, "base64");
+  }
+  if (Array.isArray(arg) && argType.scalarType === "bytes") {
+    return Buffer.from(arg);
+  }
+  if (ArrayBuffer.isView(arg)) {
+    return Buffer.from(arg.buffer, arg.byteOffset, arg.byteLength);
+  }
   return arg;
 }
 function mapRow(row, columns) {
   return row.map((value, i) => {
+    const type = columns?.[i]?.type;
     if (value instanceof Date) {
-      if (columns?.[i]?.type === sql.Time) {
-        return value.toISOString().split("T").at(1)?.replace("Z", "");
+      if (type === sql2.Time) {
+        return value.toISOString().split("T")[1].replace("Z", "");
       }
       return value.toISOString();
     }
+    if (typeof value === "number" && type === sql2.Real) {
+      for (let digits = 7; digits <= 9; digits++) {
+        const parsed = Number.parseFloat(value.toPrecision(digits));
+        if (value === new Float32Array([parsed])[0]) {
+          return parsed;
+        }
+      }
+      return value;
+    }
     if (Buffer.isBuffer(value)) {
       return Array.from(value);
     }
-    if (typeof value === "string" && columns?.[i].type === sql.UniqueIdentifier) {
+    if (typeof value === "string" && type === sql2.UniqueIdentifier) {
       return value.toLowerCase();
     }
-    if (typeof value === "boolean" && columns?.[i]?.type === sql.Bit) {
+    if (typeof value === "boolean" && type === sql2.Bit) {
       return value ? 1 : 0;
     }
     return value;
   });
 }
+function formatDateTime(date) {
+  const pad = (n, z = 2) => String(n).padStart(z, "0");
+  const ms = date.getUTCMilliseconds();
+  return date.getUTCFullYear() + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate()) + " " + pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + (ms ? "." + String(ms).padStart(3, "0") : "");
+}
+function formatDate(date) {
+  const pad = (n, z = 2) => String(n).padStart(z, "0");
+  return date.getUTCFullYear() + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate());
+}
+function formatTime(date) {
+  const pad = (n, z = 2) => String(n).padStart(z, "0");
+  const ms = date.getUTCMilliseconds();
+  return pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + (ms ? "." + String(ms).padStart(3, "0") : "");
+}
 // src/errors.ts
 function convertDriverError(error) {
@@ -298,7 +491,7 @@ function isDriverError(error) {
 }
 // src/mssql.ts
-var debug = Debug("prisma:driver-adapter:mssql");
+var debug2 = Debug2("prisma:driver-adapter:mssql");
 var MssqlQueryable = class {
   constructor(conn) {
     this.conn = conn;
@@ -307,7 +500,7 @@ var MssqlQueryable = class {
   adapterName = name;
   async queryRaw(query) {
     const tag = "[js::query_raw]";
-    debug(`${tag} %O`, query);
+    debug2(`${tag} %O`, query);
     const { recordset, columns: columnsList } = await this.performIO(query);
     const columns = columnsList?.[0];
     return {
@@ -318,7 +511,7 @@ var MssqlQueryable = class {
   }
   async executeRaw(query) {
     const tag = "[js::execute_raw]";
-    debug(`${tag} %O`, query);
+    debug2(`${tag} %O`, query);
     return (await this.performIO(query)).rowsAffected?.[0] ?? 0;
   }
   async performIO(query) {
@@ -326,7 +519,7 @@ var MssqlQueryable = class {
       const req = this.conn.request();
       req.arrayRowMode = true;
       for (let i = 0; i < query.args.length; i++) {
-        req.input(`P${i + 1}`, mapArg(query.args[i]));
+        req.input(`P${i + 1}`, mapArg(query.args[i], query.argTypes[i]));
       }
       const res = await req.query(query.sql);
       return res;
@@ -335,7 +528,7 @@ var MssqlQueryable = class {
     }
   }
   onError(error) {
-    debug("Error in performIO: %O", error);
+    debug2("Error in performIO: %O", error);
     throw new DriverAdapterError2(convertDriverError(error));
   }
 };
@@ -357,14 +550,14 @@ var MssqlTransaction = class extends MssqlQueryable {
     }
   }
   async commit() {
-    debug(`[js::commit]`);
+    debug2(`[js::commit]`);
     await this.transaction.commit();
   }
   async rollback() {
-    debug(`[js::rollback]`);
+    debug2(`[js::rollback]`);
     await this.transaction.rollback().catch((e) => {
       if (e.code === "EABORT") {
-        debug(`[js::rollback] Transaction already aborted`);
+        debug2(`[js::rollback] Transaction already aborted`);
         return;
       }
       throw e;
@@ -385,8 +578,12 @@ var PrismaMssqlAdapter = class extends MssqlQueryable {
       usePhantomQuery: true
     };
     const tag = "[js::startTransaction]";
-    debug("%s options: %O", tag, options);
+    debug2("%s options: %O", tag, options);
     const tx = this.pool.transaction();
+    tx.on("error", (err) => {
+      debug2("Error from pool connection: %O", err);
+      this.options?.onConnectionError?.(err);
+    });
     try {
       await tx.begin(isolationLevel !== void 0 ? mapIsolationLevel(isolationLevel) : void 0);
       return new MssqlTransaction(tx, options);
@@ -409,16 +606,31 @@ var PrismaMssqlAdapter = class extends MssqlQueryable {
   }
 };
 var PrismaMssqlAdapterFactory = class {
-  constructor(config, options) {
-    this.config = config;
-    this.options = options;
-  }
   provider = "sqlserver";
   adapterName = name;
+  #config;
+  #options;
+  constructor(configOrString, options) {
+    if (typeof configOrString === "string") {
+      this.#config = parseConnectionString(configOrString);
+      const extractedSchema = extractSchemaFromConnectionString(configOrString);
+      this.#options = {
+        ...options,
+        schema: options?.schema ?? extractedSchema
+      };
+    } else {
+      this.#config = configOrString;
+      this.#options = options ?? {};
+    }
+  }
   async connect() {
-    const pool = new sql2.ConnectionPool(this.config);
+    const pool = new sql3.ConnectionPool(this.#config);
+    pool.on("error", (err) => {
+      debug2("Error from pool client: %O", err);
+      this.#options?.onPoolError?.(err);
+    });
     await pool.connect();
-    return new PrismaMssqlAdapter(pool, this.options);
+    return new PrismaMssqlAdapter(pool, this.#options);
   }
 };
 export {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/adapter-mssql",
-  "version": "6.15.0-dev.3",
+  "version": "6.15.0-dev.30",
   "description": "Prisma's driver adapter for \"mssql\"",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -33,18 +33,15 @@
   "dependencies": {
     "mssql": "^11.0.1",
     "async-mutex": "0.5.0",
-    "@prisma/driver-adapter-utils": "6.15.0-dev.3"
+    "@prisma/driver-adapter-utils": "6.15.0-dev.30"
   },
   "devDependencies": {
     "@types/mssql": "9.1.7",
-    "@swc/core": "1.11.5",
-    "@swc/jest": "0.2.37",
-    "jest": "29.7.0",
-    "jest-junit": "16.0.0"
+    "vitest": "3.0.9"
   },
   "scripts": {
     "dev": "DEV=true tsx helpers/build.ts",
     "build": "tsx helpers/build.ts",
-    "test": "jest"
+    "test": "vitest run"
   }
 }