@prisma/adapter-libsql 6.6.0-integration-push-spwsqpvywlkl.10 → 6.6.0-integration-push-ytsqyomrunkq.1

package/README.md

@@ -40,6 +40,9 @@ Update your Prisma Client instance to use the libSQL database Client:
 // Import needed packages
 import { PrismaClient } from '@prisma/client'
 import { PrismaLibSQL } from '@prisma/adapter-libsql'
+// You can alternatively use the web version of the client if you're running in
+// a constrained environment where the standard libsql client doesn't work:
+// import { PrismaLibSQL } from '@prisma/adapter-libsql/web'
 
 // Setup
 const connectionString = `${process.env.TURSO_DATABASE_URL}`

package/dist/index-node.d.mts

@@ -0,0 +1,22 @@
+import { Client } from '@libsql/client';
+import { Config } from '@libsql/client';
+import type { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
+import type { SqlMigrationAwareDriverAdapterFactory } from '@prisma/driver-adapter-utils';
+
+export declare class PrismaLibSQL extends PrismaLibSQLAdapterFactoryBase {
+    createClient(config: Config): Client;
+}
+
+declare abstract class PrismaLibSQLAdapterFactoryBase implements SqlMigrationAwareDriverAdapterFactory {
+    private readonly config;
+    readonly provider = "sqlite";
+    readonly adapterName: string;
+    constructor(config: Config);
+    connect(): Promise<SqlDriverAdapter>;
+    connectToShadowDb(): Promise<SqlDriverAdapter>;
+    abstract createClient(config: Config): StdClient;
+}
+
+declare type StdClient = Client;
+
+export { }

package/dist/index-node.d.ts

@@ -0,0 +1,22 @@
+import { Client } from '@libsql/client';
+import { Config } from '@libsql/client';
+import type { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
+import type { SqlMigrationAwareDriverAdapterFactory } from '@prisma/driver-adapter-utils';
+
+export declare class PrismaLibSQL extends PrismaLibSQLAdapterFactoryBase {
+    createClient(config: Config): Client;
+}
+
+declare abstract class PrismaLibSQLAdapterFactoryBase implements SqlMigrationAwareDriverAdapterFactory {
+    private readonly config;
+    readonly provider = "sqlite";
+    readonly adapterName: string;
+    constructor(config: Config);
+    connect(): Promise<SqlDriverAdapter>;
+    connectToShadowDb(): Promise<SqlDriverAdapter>;
+    abstract createClient(config: Config): StdClient;
+}
+
+declare type StdClient = Client;
+
+export { }

package/dist/{index.js → index-node.js}

@@ -17,15 +17,17 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
+// src/index-node.ts
+var index_node_exports = {};
+__export(index_node_exports, {
   PrismaLibSQL: () => PrismaLibSQLAdapterFactory
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(index_node_exports);
 
-// src/libsql.ts
+// src/libsql-node.ts
 var import_client = require("@libsql/client");
+
+// src/libsql.ts
 var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
 var import_async_mutex = require("async-mutex");
 
@@ -297,22 +299,26 @@ var PrismaLibSQLAdapter = class extends LibSqlQueryable {
     return Promise.resolve();
   }
 };
-var PrismaLibSQLAdapterFactory = class {
+var PrismaLibSQLAdapterFactoryBase = class {
   constructor(config) {
     this.config = config;
   }
   provider = "sqlite";
   adapterName = name;
   connect() {
-    return Promise.resolve(new PrismaLibSQLAdapter(createLibSQLClient(this.config)));
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient(this.config)));
   }
   connectToShadowDb() {
-    return Promise.resolve(new PrismaLibSQLAdapter(createLibSQLClient({ ...this.config, url: ":memory:" })));
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient({ ...this.config, url: ":memory:" })));
+  }
+};
+
+// src/libsql-node.ts
+var PrismaLibSQLAdapterFactory = class extends PrismaLibSQLAdapterFactoryBase {
+  createClient(config) {
+    return (0, import_client.createClient)(config);
   }
 };
-function createLibSQLClient(config) {
-  return (0, import_client.createClient)(config);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PrismaLibSQL

package/dist/{index.mjs → index-node.mjs}

@@ -1,5 +1,7 @@
-// src/libsql.ts
+// src/libsql-node.ts
 import { createClient } from "@libsql/client";
+
+// src/libsql.ts
 import { Debug as Debug2, DriverAdapterError } from "@prisma/driver-adapter-utils";
 import { Mutex } from "async-mutex";
 
@@ -271,22 +273,26 @@ var PrismaLibSQLAdapter = class extends LibSqlQueryable {
     return Promise.resolve();
   }
 };
-var PrismaLibSQLAdapterFactory = class {
+var PrismaLibSQLAdapterFactoryBase = class {
   constructor(config) {
     this.config = config;
   }
   provider = "sqlite";
   adapterName = name;
   connect() {
-    return Promise.resolve(new PrismaLibSQLAdapter(createLibSQLClient(this.config)));
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient(this.config)));
   }
   connectToShadowDb() {
-    return Promise.resolve(new PrismaLibSQLAdapter(createLibSQLClient({ ...this.config, url: ":memory:" })));
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient({ ...this.config, url: ":memory:" })));
+  }
+};
+
+// src/libsql-node.ts
+var PrismaLibSQLAdapterFactory = class extends PrismaLibSQLAdapterFactoryBase {
+  createClient(config) {
+    return createClient(config);
   }
 };
-function createLibSQLClient(config) {
-  return createClient(config);
-}
 export {
   PrismaLibSQLAdapterFactory as PrismaLibSQL
 };

package/dist/index-web.d.mts

@@ -0,0 +1,24 @@
+import type { Client } from '@libsql/client';
+import { Client as Client_2 } from '@libsql/client/web';
+import type { Config } from '@libsql/client';
+import { Config as Config_2 } from '@libsql/client/web';
+import type { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
+import type { SqlMigrationAwareDriverAdapterFactory } from '@prisma/driver-adapter-utils';
+
+export declare class PrismaLibSQL extends PrismaLibSQLAdapterFactoryBase {
+    createClient(config: Config_2): Client_2;
+}
+
+declare abstract class PrismaLibSQLAdapterFactoryBase implements SqlMigrationAwareDriverAdapterFactory {
+    private readonly config;
+    readonly provider = "sqlite";
+    readonly adapterName: string;
+    constructor(config: Config);
+    connect(): Promise<SqlDriverAdapter>;
+    connectToShadowDb(): Promise<SqlDriverAdapter>;
+    abstract createClient(config: Config): StdClient;
+}
+
+declare type StdClient = Client;
+
+export { }

package/dist/index-web.d.ts

@@ -0,0 +1,24 @@
+import type { Client } from '@libsql/client';
+import { Client as Client_2 } from '@libsql/client/web';
+import type { Config } from '@libsql/client';
+import { Config as Config_2 } from '@libsql/client/web';
+import type { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
+import type { SqlMigrationAwareDriverAdapterFactory } from '@prisma/driver-adapter-utils';
+
+export declare class PrismaLibSQL extends PrismaLibSQLAdapterFactoryBase {
+    createClient(config: Config_2): Client_2;
+}
+
+declare abstract class PrismaLibSQLAdapterFactoryBase implements SqlMigrationAwareDriverAdapterFactory {
+    private readonly config;
+    readonly provider = "sqlite";
+    readonly adapterName: string;
+    constructor(config: Config);
+    connect(): Promise<SqlDriverAdapter>;
+    connectToShadowDb(): Promise<SqlDriverAdapter>;
+    abstract createClient(config: Config): StdClient;
+}
+
+declare type StdClient = Client;
+
+export { }

package/dist/index-web.js

@@ -0,0 +1,325 @@
+"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 name2 in all)
+    __defProp(target, name2, { get: all[name2], 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);
+
+// src/index-web.ts
+var index_web_exports = {};
+__export(index_web_exports, {
+  PrismaLibSQL: () => PrismaLibSQLWebAdapterFactory
+});
+module.exports = __toCommonJS(index_web_exports);
+
+// src/libsql-web.ts
+var import_web = require("@libsql/client/web");
+
+// src/libsql.ts
+var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
+var import_async_mutex = require("async-mutex");
+
+// package.json
+var name = "@prisma/adapter-libsql";
+
+// src/conversion.ts
+var import_driver_adapter_utils = require("@prisma/driver-adapter-utils");
+var debug = (0, import_driver_adapter_utils.Debug)("prisma:driver-adapter:libsql:conversion");
+function mapDeclType(declType) {
+  switch (declType.toUpperCase()) {
+    case "":
+      return null;
+    case "DECIMAL":
+      return import_driver_adapter_utils.ColumnTypeEnum.Numeric;
+    case "FLOAT":
+      return import_driver_adapter_utils.ColumnTypeEnum.Float;
+    case "DOUBLE":
+    case "DOUBLE PRECISION":
+    case "NUMERIC":
+    case "REAL":
+      return import_driver_adapter_utils.ColumnTypeEnum.Double;
+    case "TINYINT":
+    case "SMALLINT":
+    case "MEDIUMINT":
+    case "INT":
+    case "INTEGER":
+    case "SERIAL":
+    case "INT2":
+      return import_driver_adapter_utils.ColumnTypeEnum.Int32;
+    case "BIGINT":
+    case "UNSIGNED BIG INT":
+    case "INT8":
+      return import_driver_adapter_utils.ColumnTypeEnum.Int64;
+    case "DATETIME":
+    case "TIMESTAMP":
+      return import_driver_adapter_utils.ColumnTypeEnum.DateTime;
+    case "TIME":
+      return import_driver_adapter_utils.ColumnTypeEnum.Time;
+    case "DATE":
+      return import_driver_adapter_utils.ColumnTypeEnum.Date;
+    case "TEXT":
+    case "CLOB":
+    case "CHARACTER":
+    case "VARCHAR":
+    case "VARYING CHARACTER":
+    case "NCHAR":
+    case "NATIVE CHARACTER":
+    case "NVARCHAR":
+      return import_driver_adapter_utils.ColumnTypeEnum.Text;
+    case "BLOB":
+      return import_driver_adapter_utils.ColumnTypeEnum.Bytes;
+    case "BOOLEAN":
+      return import_driver_adapter_utils.ColumnTypeEnum.Boolean;
+    case "JSONB":
+      return import_driver_adapter_utils.ColumnTypeEnum.Json;
+    default:
+      debug("unknown decltype:", declType);
+      return null;
+  }
+}
+function mapDeclaredColumnTypes(columnTypes) {
+  const emptyIndices = /* @__PURE__ */ new Set();
+  const result = columnTypes.map((typeName, index) => {
+    const mappedType = mapDeclType(typeName);
+    if (mappedType === null) {
+      emptyIndices.add(index);
+    }
+    return mappedType;
+  });
+  return [result, emptyIndices];
+}
+function getColumnTypes(declaredTypes, rows) {
+  const [columnTypes, emptyIndices] = mapDeclaredColumnTypes(declaredTypes);
+  if (emptyIndices.size === 0) {
+    return columnTypes;
+  }
+  columnLoop: for (const columnIndex of emptyIndices) {
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+      const candidateValue = rows[rowIndex][columnIndex];
+      if (candidateValue !== null) {
+        columnTypes[columnIndex] = inferColumnType(candidateValue);
+        continue columnLoop;
+      }
+    }
+    columnTypes[columnIndex] = import_driver_adapter_utils.ColumnTypeEnum.Int32;
+  }
+  return columnTypes;
+}
+function inferColumnType(value) {
+  switch (typeof value) {
+    case "string":
+      return import_driver_adapter_utils.ColumnTypeEnum.Text;
+    case "bigint":
+      return import_driver_adapter_utils.ColumnTypeEnum.Int64;
+    case "boolean":
+      return import_driver_adapter_utils.ColumnTypeEnum.Boolean;
+    case "number":
+      return import_driver_adapter_utils.ColumnTypeEnum.UnknownNumber;
+    case "object":
+      return inferObjectType(value);
+    default:
+      throw new UnexpectedTypeError(value);
+  }
+}
+function inferObjectType(value) {
+  if (value instanceof ArrayBuffer) {
+    return import_driver_adapter_utils.ColumnTypeEnum.Bytes;
+  }
+  throw new UnexpectedTypeError(value);
+}
+var UnexpectedTypeError = class extends Error {
+  name = "UnexpectedTypeError";
+  constructor(value) {
+    const type = typeof value;
+    const repr = type === "object" ? JSON.stringify(value) : String(value);
+    super(`unexpected value of type ${type}: ${repr}`);
+  }
+};
+function mapRow(row, columnTypes) {
+  const result = Array.from(row);
+  for (let i = 0; i < result.length; i++) {
+    const value = result[i];
+    if (value instanceof ArrayBuffer) {
+      result[i] = Array.from(new Uint8Array(value));
+      continue;
+    }
+    if (typeof value === "number" && (columnTypes[i] === import_driver_adapter_utils.ColumnTypeEnum.Int32 || columnTypes[i] === import_driver_adapter_utils.ColumnTypeEnum.Int64) && !Number.isInteger(value)) {
+      result[i] = Math.trunc(value);
+      continue;
+    }
+    if (["number", "bigint"].includes(typeof value) && columnTypes[i] === import_driver_adapter_utils.ColumnTypeEnum.DateTime) {
+      result[i] = new Date(Number(value)).toISOString();
+      continue;
+    }
+    if (typeof value === "bigint") {
+      result[i] = value.toString();
+      continue;
+    }
+  }
+  return result;
+}
+
+// src/libsql.ts
+var debug2 = (0, import_driver_adapter_utils2.Debug)("prisma:driver-adapter:libsql");
+var LOCK_TAG = Symbol();
+var LibSqlQueryable = class {
+  constructor(client) {
+    this.client = client;
+  }
+  provider = "sqlite";
+  adapterName = name;
+  [LOCK_TAG] = new import_async_mutex.Mutex();
+  /**
+   * Execute a query given as SQL, interpolating the given parameters.
+   */
+  async queryRaw(query) {
+    const tag = "[js::query_raw]";
+    debug2(`${tag} %O`, query);
+    const { columns, rows, columnTypes: declaredColumnTypes } = await this.performIO(query);
+    const columnTypes = getColumnTypes(declaredColumnTypes, rows);
+    return {
+      columnNames: columns,
+      columnTypes,
+      rows: rows.map((row) => mapRow(row, columnTypes))
+    };
+  }
+  /**
+   * Execute a query given as SQL, interpolating the given parameters and
+   * returning the number of affected rows.
+   * Note: Queryable expects a u64, but napi.rs only supports u32.
+   */
+  async executeRaw(query) {
+    const tag = "[js::execute_raw]";
+    debug2(`${tag} %O`, query);
+    return (await this.performIO(query)).rowsAffected ?? 0;
+  }
+  /**
+   * Run a query against the database, returning the result set.
+   * Should the query fail due to a connection error, the connection is
+   * marked as unhealthy.
+   */
+  async performIO(query) {
+    const release = await this[LOCK_TAG].acquire();
+    try {
+      const result = await this.client.execute(query);
+      return result;
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      release();
+    }
+  }
+  onError(error) {
+    debug2("Error in performIO: %O", error);
+    const rawCode = error["rawCode"] ?? error.cause?.["rawCode"];
+    if (typeof rawCode === "number") {
+      throw new import_driver_adapter_utils2.DriverAdapterError({
+        kind: "sqlite",
+        extendedCode: rawCode,
+        message: error.message
+      });
+    }
+    throw error;
+  }
+};
+var LibSqlTransaction = class extends LibSqlQueryable {
+  constructor(client, options, unlockParent) {
+    super(client);
+    this.options = options;
+    this.unlockParent = unlockParent;
+  }
+  async commit() {
+    debug2(`[js::commit]`);
+    try {
+      await this.client.commit();
+    } finally {
+      this.unlockParent();
+    }
+  }
+  async rollback() {
+    debug2(`[js::rollback]`);
+    try {
+      await this.client.rollback();
+    } catch (error) {
+      debug2("error in rollback:", error);
+    } finally {
+      this.unlockParent();
+    }
+  }
+};
+var PrismaLibSQLAdapter = class extends LibSqlQueryable {
+  constructor(client) {
+    super(client);
+  }
+  async executeScript(script) {
+    const release = await this[LOCK_TAG].acquire();
+    try {
+      await this.client.executeMultiple(script);
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      release();
+    }
+  }
+  async startTransaction(isolationLevel) {
+    if (isolationLevel && isolationLevel !== "SERIALIZABLE") {
+      throw new import_driver_adapter_utils2.DriverAdapterError({
+        kind: "InvalidIsolationLevel",
+        level: isolationLevel
+      });
+    }
+    const options = {
+      usePhantomQuery: true
+    };
+    const tag = "[js::startTransaction]";
+    debug2("%s options: %O", tag, options);
+    const release = await this[LOCK_TAG].acquire();
+    try {
+      const tx = await this.client.transaction("deferred");
+      return new LibSqlTransaction(tx, options, release);
+    } catch (e) {
+      release();
+      throw e;
+    }
+  }
+  dispose() {
+    this.client.close();
+    return Promise.resolve();
+  }
+};
+var PrismaLibSQLAdapterFactoryBase = class {
+  constructor(config) {
+    this.config = config;
+  }
+  provider = "sqlite";
+  adapterName = name;
+  connect() {
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient(this.config)));
+  }
+  connectToShadowDb() {
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient({ ...this.config, url: ":memory:" })));
+  }
+};
+
+// src/libsql-web.ts
+var PrismaLibSQLWebAdapterFactory = class extends PrismaLibSQLAdapterFactoryBase {
+  createClient(config) {
+    return (0, import_web.createClient)(config);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrismaLibSQL
+});

package/dist/index-web.mjs

@@ -0,0 +1,298 @@
+// src/libsql-web.ts
+import { createClient } from "@libsql/client/web";
+
+// src/libsql.ts
+import { Debug as Debug2, DriverAdapterError } from "@prisma/driver-adapter-utils";
+import { Mutex } from "async-mutex";
+
+// package.json
+var name = "@prisma/adapter-libsql";
+
+// src/conversion.ts
+import { ColumnTypeEnum, Debug } from "@prisma/driver-adapter-utils";
+var debug = Debug("prisma:driver-adapter:libsql:conversion");
+function mapDeclType(declType) {
+  switch (declType.toUpperCase()) {
+    case "":
+      return null;
+    case "DECIMAL":
+      return ColumnTypeEnum.Numeric;
+    case "FLOAT":
+      return ColumnTypeEnum.Float;
+    case "DOUBLE":
+    case "DOUBLE PRECISION":
+    case "NUMERIC":
+    case "REAL":
+      return ColumnTypeEnum.Double;
+    case "TINYINT":
+    case "SMALLINT":
+    case "MEDIUMINT":
+    case "INT":
+    case "INTEGER":
+    case "SERIAL":
+    case "INT2":
+      return ColumnTypeEnum.Int32;
+    case "BIGINT":
+    case "UNSIGNED BIG INT":
+    case "INT8":
+      return ColumnTypeEnum.Int64;
+    case "DATETIME":
+    case "TIMESTAMP":
+      return ColumnTypeEnum.DateTime;
+    case "TIME":
+      return ColumnTypeEnum.Time;
+    case "DATE":
+      return ColumnTypeEnum.Date;
+    case "TEXT":
+    case "CLOB":
+    case "CHARACTER":
+    case "VARCHAR":
+    case "VARYING CHARACTER":
+    case "NCHAR":
+    case "NATIVE CHARACTER":
+    case "NVARCHAR":
+      return ColumnTypeEnum.Text;
+    case "BLOB":
+      return ColumnTypeEnum.Bytes;
+    case "BOOLEAN":
+      return ColumnTypeEnum.Boolean;
+    case "JSONB":
+      return ColumnTypeEnum.Json;
+    default:
+      debug("unknown decltype:", declType);
+      return null;
+  }
+}
+function mapDeclaredColumnTypes(columnTypes) {
+  const emptyIndices = /* @__PURE__ */ new Set();
+  const result = columnTypes.map((typeName, index) => {
+    const mappedType = mapDeclType(typeName);
+    if (mappedType === null) {
+      emptyIndices.add(index);
+    }
+    return mappedType;
+  });
+  return [result, emptyIndices];
+}
+function getColumnTypes(declaredTypes, rows) {
+  const [columnTypes, emptyIndices] = mapDeclaredColumnTypes(declaredTypes);
+  if (emptyIndices.size === 0) {
+    return columnTypes;
+  }
+  columnLoop: for (const columnIndex of emptyIndices) {
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+      const candidateValue = rows[rowIndex][columnIndex];
+      if (candidateValue !== null) {
+        columnTypes[columnIndex] = inferColumnType(candidateValue);
+        continue columnLoop;
+      }
+    }
+    columnTypes[columnIndex] = ColumnTypeEnum.Int32;
+  }
+  return columnTypes;
+}
+function inferColumnType(value) {
+  switch (typeof value) {
+    case "string":
+      return ColumnTypeEnum.Text;
+    case "bigint":
+      return ColumnTypeEnum.Int64;
+    case "boolean":
+      return ColumnTypeEnum.Boolean;
+    case "number":
+      return ColumnTypeEnum.UnknownNumber;
+    case "object":
+      return inferObjectType(value);
+    default:
+      throw new UnexpectedTypeError(value);
+  }
+}
+function inferObjectType(value) {
+  if (value instanceof ArrayBuffer) {
+    return ColumnTypeEnum.Bytes;
+  }
+  throw new UnexpectedTypeError(value);
+}
+var UnexpectedTypeError = class extends Error {
+  name = "UnexpectedTypeError";
+  constructor(value) {
+    const type = typeof value;
+    const repr = type === "object" ? JSON.stringify(value) : String(value);
+    super(`unexpected value of type ${type}: ${repr}`);
+  }
+};
+function mapRow(row, columnTypes) {
+  const result = Array.from(row);
+  for (let i = 0; i < result.length; i++) {
+    const value = result[i];
+    if (value instanceof ArrayBuffer) {
+      result[i] = Array.from(new Uint8Array(value));
+      continue;
+    }
+    if (typeof value === "number" && (columnTypes[i] === ColumnTypeEnum.Int32 || columnTypes[i] === ColumnTypeEnum.Int64) && !Number.isInteger(value)) {
+      result[i] = Math.trunc(value);
+      continue;
+    }
+    if (["number", "bigint"].includes(typeof value) && columnTypes[i] === ColumnTypeEnum.DateTime) {
+      result[i] = new Date(Number(value)).toISOString();
+      continue;
+    }
+    if (typeof value === "bigint") {
+      result[i] = value.toString();
+      continue;
+    }
+  }
+  return result;
+}
+
+// src/libsql.ts
+var debug2 = Debug2("prisma:driver-adapter:libsql");
+var LOCK_TAG = Symbol();
+var LibSqlQueryable = class {
+  constructor(client) {
+    this.client = client;
+  }
+  provider = "sqlite";
+  adapterName = name;
+  [LOCK_TAG] = new Mutex();
+  /**
+   * Execute a query given as SQL, interpolating the given parameters.
+   */
+  async queryRaw(query) {
+    const tag = "[js::query_raw]";
+    debug2(`${tag} %O`, query);
+    const { columns, rows, columnTypes: declaredColumnTypes } = await this.performIO(query);
+    const columnTypes = getColumnTypes(declaredColumnTypes, rows);
+    return {
+      columnNames: columns,
+      columnTypes,
+      rows: rows.map((row) => mapRow(row, columnTypes))
+    };
+  }
+  /**
+   * Execute a query given as SQL, interpolating the given parameters and
+   * returning the number of affected rows.
+   * Note: Queryable expects a u64, but napi.rs only supports u32.
+   */
+  async executeRaw(query) {
+    const tag = "[js::execute_raw]";
+    debug2(`${tag} %O`, query);
+    return (await this.performIO(query)).rowsAffected ?? 0;
+  }
+  /**
+   * Run a query against the database, returning the result set.
+   * Should the query fail due to a connection error, the connection is
+   * marked as unhealthy.
+   */
+  async performIO(query) {
+    const release = await this[LOCK_TAG].acquire();
+    try {
+      const result = await this.client.execute(query);
+      return result;
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      release();
+    }
+  }
+  onError(error) {
+    debug2("Error in performIO: %O", error);
+    const rawCode = error["rawCode"] ?? error.cause?.["rawCode"];
+    if (typeof rawCode === "number") {
+      throw new DriverAdapterError({
+        kind: "sqlite",
+        extendedCode: rawCode,
+        message: error.message
+      });
+    }
+    throw error;
+  }
+};
+var LibSqlTransaction = class extends LibSqlQueryable {
+  constructor(client, options, unlockParent) {
+    super(client);
+    this.options = options;
+    this.unlockParent = unlockParent;
+  }
+  async commit() {
+    debug2(`[js::commit]`);
+    try {
+      await this.client.commit();
+    } finally {
+      this.unlockParent();
+    }
+  }
+  async rollback() {
+    debug2(`[js::rollback]`);
+    try {
+      await this.client.rollback();
+    } catch (error) {
+      debug2("error in rollback:", error);
+    } finally {
+      this.unlockParent();
+    }
+  }
+};
+var PrismaLibSQLAdapter = class extends LibSqlQueryable {
+  constructor(client) {
+    super(client);
+  }
+  async executeScript(script) {
+    const release = await this[LOCK_TAG].acquire();
+    try {
+      await this.client.executeMultiple(script);
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      release();
+    }
+  }
+  async startTransaction(isolationLevel) {
+    if (isolationLevel && isolationLevel !== "SERIALIZABLE") {
+      throw new DriverAdapterError({
+        kind: "InvalidIsolationLevel",
+        level: isolationLevel
+      });
+    }
+    const options = {
+      usePhantomQuery: true
+    };
+    const tag = "[js::startTransaction]";
+    debug2("%s options: %O", tag, options);
+    const release = await this[LOCK_TAG].acquire();
+    try {
+      const tx = await this.client.transaction("deferred");
+      return new LibSqlTransaction(tx, options, release);
+    } catch (e) {
+      release();
+      throw e;
+    }
+  }
+  dispose() {
+    this.client.close();
+    return Promise.resolve();
+  }
+};
+var PrismaLibSQLAdapterFactoryBase = class {
+  constructor(config) {
+    this.config = config;
+  }
+  provider = "sqlite";
+  adapterName = name;
+  connect() {
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient(this.config)));
+  }
+  connectToShadowDb() {
+    return Promise.resolve(new PrismaLibSQLAdapter(this.createClient({ ...this.config, url: ":memory:" })));
+  }
+};
+
+// src/libsql-web.ts
+var PrismaLibSQLWebAdapterFactory = class extends PrismaLibSQLAdapterFactoryBase {
+  createClient(config) {
+    return createClient(config);
+  }
+};
+export {
+  PrismaLibSQLWebAdapterFactory as PrismaLibSQL
+};

package/package.json

@@ -1,19 +1,29 @@
 {
   "name": "@prisma/adapter-libsql",
-  "version": "6.6.0-integration-push-spwsqpvywlkl.10",
+  "version": "6.6.0-integration-push-ytsqyomrunkq.1",
   "description": "Prisma's driver adapter for libSQL and Turso",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "dist/index-node.js",
+  "module": "dist/index-node.mjs",
+  "types": "dist/index-node.d.ts",
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index-node.d.ts",
+        "default": "./dist/index-node.js"
       },
       "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./dist/index-node.d.mts",
+        "default": "./dist/index-node.mjs"
+      }
+    },
+    "./web": {
+      "require": {
+        "types": "./dist/index-web.d.ts",
+        "default": "./dist/index-web.js"
+      },
+      "import": {
+        "types": "./dist/index-web.d.mts",
+        "default": "./dist/index-web.mjs"
       }
     }
   },
@@ -31,17 +41,17 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
+    "@libsql/client": "^0.3.5 || ^0.4.0 || ^0.5.0 || ^0.6.0 || ^0.7.0 || ^0.8.0",
     "async-mutex": "0.5.0",
-    "@prisma/driver-adapter-utils": "6.6.0-integration-push-spwsqpvywlkl.10"
+    "@prisma/driver-adapter-utils": "6.6.0-integration-push-ytsqyomrunkq.1"
   },
   "devDependencies": {
-    "@libsql/client": "0.8.0"
-  },
-  "peerDependencies": {
-    "@libsql/client": "^0.3.5 || ^0.4.0 || ^0.5.0 || ^0.6.0 || ^0.7.0 || ^0.8.0"
+    "jest": "29.7.0",
+    "jest-junit": "16.0.0"
   },
   "scripts": {
     "dev": "DEV=true tsx helpers/build.ts",
-    "build": "tsx helpers/build.ts"
+    "build": "tsx helpers/build.ts",
+    "test": "jest"
   }
 }

package/dist/index.d.mts

@@ -1,14 +0,0 @@
-import type { Config } from '@libsql/client';
-import type { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
-import type { SqlMigrationAwareDriverAdapterFactory } from '@prisma/driver-adapter-utils';
-
-export declare class PrismaLibSQL implements SqlMigrationAwareDriverAdapterFactory {
-    private readonly config;
-    readonly provider = "sqlite";
-    readonly adapterName: string;
-    constructor(config: Config);
-    connect(): Promise<SqlDriverAdapter>;
-    connectToShadowDb(): Promise<SqlDriverAdapter>;
-}
-
-export { }

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-import type { Config } from '@libsql/client';
-import type { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
-import type { SqlMigrationAwareDriverAdapterFactory } from '@prisma/driver-adapter-utils';
-
-export declare class PrismaLibSQL implements SqlMigrationAwareDriverAdapterFactory {
-    private readonly config;
-    readonly provider = "sqlite";
-    readonly adapterName: string;
-    constructor(config: Config);
-    connect(): Promise<SqlDriverAdapter>;
-    connectToShadowDb(): Promise<SqlDriverAdapter>;
-}
-
-export { }