drizzle-orm 0.34.1-a345cb3 → 0.34.1-a88d6b6

package/monodriver.d.cts

@@ -1,192 +0,0 @@
-import type { RDSDataClient, RDSDataClientConfig as RDSConfig } from '@aws-sdk/client-rds-data';
-import type { PGlite, PGliteOptions } from '@electric-sql/pglite';
-import type { Client as LibsqlClient, Config as LibsqlConfig } from '@libsql/client';
-import type { HTTPTransactionOptions as NeonHttpConfig, NeonQueryFunction, Pool as NeonServerlessPool, PoolConfig as NeonServerlessConfig, QueryResult, QueryResultRow } from '@neondatabase/serverless';
-import type { Client as PlanetscaleClient, Config as PlanetscaleConfig } from '@planetscale/database';
-import type { Config as TiDBServerlessConfig, Connection as TiDBConnection } from '@tidbcloud/serverless';
-import type { VercelPool } from '@vercel/postgres';
-import type { Database as BetterSQLite3Database, Options as BetterSQLite3Options } from 'better-sqlite3';
-import type { Database as BunDatabase } from 'bun:sqlite';
-import type { Pool as Mysql2Pool, PoolOptions as Mysql2Config } from 'mysql2';
-import type { Pool as NodePgPool, PoolConfig as NodePgPoolConfig } from 'pg';
-import type { Options as PostgresJSOptions, PostgresType as PostgresJSPostgresType, Sql as PostgresJsClient } from 'postgres';
-import type { AwsDataApiPgDatabase, DrizzleAwsDataApiPgConfig } from "./aws-data-api/pg/index.cjs";
-import type { BetterSQLite3Database as DrizzleBetterSQLite3Database } from "./better-sqlite3/index.cjs";
-import type { BunSQLiteDatabase } from "./bun-sqlite/index.cjs";
-import type { AnyD1Database, DrizzleD1Database } from "./d1/index.cjs";
-import type { LibSQLDatabase } from "./libsql/index.cjs";
-import type { MySql2Database, MySql2DrizzleConfig } from "./mysql2/index.cjs";
-import type { NeonHttpDatabase } from "./neon-http/index.cjs";
-import type { NeonDatabase } from "./neon-serverless/index.cjs";
-import type { NodePgDatabase } from "./node-postgres/driver.cjs";
-import type { PgliteDatabase } from "./pglite/driver.cjs";
-import type { PlanetScaleDatabase } from "./planetscale-serverless/index.cjs";
-import type { PostgresJsDatabase } from "./postgres-js/index.cjs";
-import type { TiDBServerlessDatabase } from "./tidb-serverless/index.cjs";
-import type { DrizzleConfig, IfNotImported } from "./utils.cjs";
-import type { VercelPgDatabase } from "./vercel-postgres/index.cjs";
-type BunSqliteDatabaseOptions = {
-    /**
-     * Open the database as read-only (no write operations, no create).
-     *
-     * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-     */
-    readonly?: boolean;
-    /**
-     * Allow creating a new database
-     *
-     * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-     */
-    create?: boolean;
-    /**
-     * Open the database as read-write
-     *
-     * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-     */
-    readwrite?: boolean;
-};
-type BunSqliteDatabaseConfig = ({
-    source?: string;
-} & BunSqliteDatabaseOptions) | string | undefined;
-type BetterSQLite3DatabaseConfig = ({
-    source?: string | Buffer;
-} & BetterSQLite3Options) | string | undefined;
-type MonodriverNeonHttpConfig = ({
-    connectionString: string;
-} & NeonHttpConfig<boolean, boolean>) | string;
-type AwsDataApiConnectionConfig = RDSConfig & Omit<DrizzleAwsDataApiPgConfig, keyof DrizzleConfig>;
-type DatabaseClient = 'node-postgres' | 'postgres-js' | 'neon-websocket' | 'neon-http' | 'vercel-postgres' | 'aws-data-api-pg' | 'planetscale' | 'mysql2' | 'tidb-serverless' | 'libsql' | 'turso' | 'd1' | 'bun:sqlite' | 'better-sqlite3' | 'pglite';
-type ClientDrizzleInstanceMap<TSchema extends Record<string, any>> = {
-    'node-postgres': NodePgDatabase<TSchema>;
-    'postgres-js': PostgresJsDatabase<TSchema>;
-    'neon-websocket': NeonDatabase<TSchema>;
-    'neon-http': NeonHttpDatabase<TSchema>;
-    'vercel-postgres': VercelPgDatabase<TSchema>;
-    'aws-data-api-pg': AwsDataApiPgDatabase<TSchema>;
-    planetscale: PlanetScaleDatabase<TSchema>;
-    mysql2: MySql2Database<TSchema>;
-    'tidb-serverless': TiDBServerlessDatabase<TSchema>;
-    libsql: LibSQLDatabase<TSchema>;
-    turso: LibSQLDatabase<TSchema>;
-    d1: DrizzleD1Database<TSchema>;
-    'bun:sqlite': BunSQLiteDatabase<TSchema>;
-    'better-sqlite3': DrizzleBetterSQLite3Database<TSchema>;
-    pglite: PgliteDatabase<TSchema>;
-};
-type Primitive = string | number | boolean | undefined | null;
-type ClientInstanceMap = {
-    'node-postgres': NodePgPool;
-    'postgres-js': PostgresJsClient;
-    'neon-websocket': NeonServerlessPool;
-    'neon-http': NeonQueryFunction<boolean, boolean>;
-    'vercel-postgres': VercelPool & (<O extends QueryResultRow>(strings: TemplateStringsArray, ...values: Primitive[]) => Promise<QueryResult<O>>);
-    'aws-data-api-pg': RDSDataClient;
-    planetscale: PlanetscaleClient;
-    mysql2: Mysql2Pool;
-    'tidb-serverless': TiDBConnection;
-    libsql: LibsqlClient;
-    turso: LibsqlClient;
-    d1: AnyD1Database;
-    'bun:sqlite': BunDatabase;
-    'better-sqlite3': BetterSQLite3Database;
-    pglite: PGlite;
-};
-type ClientTypeImportErrorMap = {
-    'node-postgres': 'pg`, `@types/pg';
-    'postgres-js': 'postgres';
-    'neon-websocket': '@neondatabase/serverless';
-    'neon-http': '@neondatabase/serverless';
-    'vercel-postgres': '@vercel/postgres';
-    'aws-data-api-pg': '@aws-sdk/client-rds-data';
-    planetscale: '@planetscale/database';
-    mysql2: 'mysql2';
-    'tidb-serverless': '@tidbcloud/serverless';
-    libsql: '@libsql/client';
-    turso: '@libsql/client';
-    d1: '@cloudflare/workers-types` or `@miniflare/d1';
-    'bun:sqlite': 'bun-types';
-    'better-sqlite3': 'better-sqlite3';
-    pglite: '@electric-sql/pglite';
-};
-type ImportTypeError<TClient extends DatabaseClient> = `Please install \`${ClientTypeImportErrorMap[TClient]}\`to allow Drizzle ORM to connect to the database`;
-type InitializerParams = {
-    'node-postgres': {
-        connection: string | NodePgPoolConfig;
-    };
-    'postgres-js': {
-        connection: string | ({
-            url?: string;
-        } & PostgresJSOptions<Record<string, PostgresJSPostgresType>>);
-    };
-    'neon-websocket': {
-        connection: string | NeonServerlessConfig;
-    };
-    'neon-http': {
-        connection: MonodriverNeonHttpConfig;
-    };
-    'vercel-postgres': {};
-    'aws-data-api-pg': {
-        connection: AwsDataApiConnectionConfig;
-    };
-    planetscale: {
-        connection: PlanetscaleConfig | string;
-    };
-    mysql2: {
-        connection: Mysql2Config | string;
-    };
-    'tidb-serverless': {
-        connection: TiDBServerlessConfig | string;
-    };
-    libsql: {
-        connection: LibsqlConfig | string;
-    };
-    turso: {
-        connection: LibsqlConfig | string;
-    };
-    d1: {
-        connection: AnyD1Database;
-    };
-    'bun:sqlite': {
-        connection?: BunSqliteDatabaseConfig;
-    };
-    'better-sqlite3': {
-        connection?: BetterSQLite3DatabaseConfig;
-    };
-    pglite: {
-        connection?: (PGliteOptions & {
-            dataDir?: string;
-        }) | string;
-    };
-};
-type DetermineClient<TClient extends DatabaseClient, TSchema extends Record<string, unknown>> = ClientDrizzleInstanceMap<TSchema>[TClient] & {
-    $client: ClientInstanceMap[TClient];
-};
-export declare function drizzle<TClient extends DatabaseClient, TSchema extends Record<string, unknown> = Record<string, never>>(client: TClient, ...params: TClient extends 'bun:sqlite' | 'better-sqlite3' | 'pglite' ? ([
-] | [
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-] | [string]) : TClient extends 'vercel-postgres' ? ([] | [
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-]) : TClient extends 'postgres-js' | 'tidb-serverless' | 'libsql' | 'turso' | 'planetscale' | 'neon-http' | 'node-postgres' ? ([
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-] | [string]) : TClient extends 'mysql2' ? ([
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & MySql2DrizzleConfig<TSchema>)
-] | [string]) : TClient extends 'neon-websocket' ? ([
-    IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema> & {
-        ws?: any;
-    }
-] | [string]) : [
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-]): Promise<DetermineClient<TClient, TSchema>>;
-export {};

package/monodriver.d.ts

@@ -1,192 +0,0 @@
-import type { RDSDataClient, RDSDataClientConfig as RDSConfig } from '@aws-sdk/client-rds-data';
-import type { PGlite, PGliteOptions } from '@electric-sql/pglite';
-import type { Client as LibsqlClient, Config as LibsqlConfig } from '@libsql/client';
-import type { HTTPTransactionOptions as NeonHttpConfig, NeonQueryFunction, Pool as NeonServerlessPool, PoolConfig as NeonServerlessConfig, QueryResult, QueryResultRow } from '@neondatabase/serverless';
-import type { Client as PlanetscaleClient, Config as PlanetscaleConfig } from '@planetscale/database';
-import type { Config as TiDBServerlessConfig, Connection as TiDBConnection } from '@tidbcloud/serverless';
-import type { VercelPool } from '@vercel/postgres';
-import type { Database as BetterSQLite3Database, Options as BetterSQLite3Options } from 'better-sqlite3';
-import type { Database as BunDatabase } from 'bun:sqlite';
-import type { Pool as Mysql2Pool, PoolOptions as Mysql2Config } from 'mysql2';
-import type { Pool as NodePgPool, PoolConfig as NodePgPoolConfig } from 'pg';
-import type { Options as PostgresJSOptions, PostgresType as PostgresJSPostgresType, Sql as PostgresJsClient } from 'postgres';
-import type { AwsDataApiPgDatabase, DrizzleAwsDataApiPgConfig } from "./aws-data-api/pg/index.js";
-import type { BetterSQLite3Database as DrizzleBetterSQLite3Database } from "./better-sqlite3/index.js";
-import type { BunSQLiteDatabase } from "./bun-sqlite/index.js";
-import type { AnyD1Database, DrizzleD1Database } from "./d1/index.js";
-import type { LibSQLDatabase } from "./libsql/index.js";
-import type { MySql2Database, MySql2DrizzleConfig } from "./mysql2/index.js";
-import type { NeonHttpDatabase } from "./neon-http/index.js";
-import type { NeonDatabase } from "./neon-serverless/index.js";
-import type { NodePgDatabase } from "./node-postgres/driver.js";
-import type { PgliteDatabase } from "./pglite/driver.js";
-import type { PlanetScaleDatabase } from "./planetscale-serverless/index.js";
-import type { PostgresJsDatabase } from "./postgres-js/index.js";
-import type { TiDBServerlessDatabase } from "./tidb-serverless/index.js";
-import type { DrizzleConfig, IfNotImported } from "./utils.js";
-import type { VercelPgDatabase } from "./vercel-postgres/index.js";
-type BunSqliteDatabaseOptions = {
-    /**
-     * Open the database as read-only (no write operations, no create).
-     *
-     * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-     */
-    readonly?: boolean;
-    /**
-     * Allow creating a new database
-     *
-     * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-     */
-    create?: boolean;
-    /**
-     * Open the database as read-write
-     *
-     * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-     */
-    readwrite?: boolean;
-};
-type BunSqliteDatabaseConfig = ({
-    source?: string;
-} & BunSqliteDatabaseOptions) | string | undefined;
-type BetterSQLite3DatabaseConfig = ({
-    source?: string | Buffer;
-} & BetterSQLite3Options) | string | undefined;
-type MonodriverNeonHttpConfig = ({
-    connectionString: string;
-} & NeonHttpConfig<boolean, boolean>) | string;
-type AwsDataApiConnectionConfig = RDSConfig & Omit<DrizzleAwsDataApiPgConfig, keyof DrizzleConfig>;
-type DatabaseClient = 'node-postgres' | 'postgres-js' | 'neon-websocket' | 'neon-http' | 'vercel-postgres' | 'aws-data-api-pg' | 'planetscale' | 'mysql2' | 'tidb-serverless' | 'libsql' | 'turso' | 'd1' | 'bun:sqlite' | 'better-sqlite3' | 'pglite';
-type ClientDrizzleInstanceMap<TSchema extends Record<string, any>> = {
-    'node-postgres': NodePgDatabase<TSchema>;
-    'postgres-js': PostgresJsDatabase<TSchema>;
-    'neon-websocket': NeonDatabase<TSchema>;
-    'neon-http': NeonHttpDatabase<TSchema>;
-    'vercel-postgres': VercelPgDatabase<TSchema>;
-    'aws-data-api-pg': AwsDataApiPgDatabase<TSchema>;
-    planetscale: PlanetScaleDatabase<TSchema>;
-    mysql2: MySql2Database<TSchema>;
-    'tidb-serverless': TiDBServerlessDatabase<TSchema>;
-    libsql: LibSQLDatabase<TSchema>;
-    turso: LibSQLDatabase<TSchema>;
-    d1: DrizzleD1Database<TSchema>;
-    'bun:sqlite': BunSQLiteDatabase<TSchema>;
-    'better-sqlite3': DrizzleBetterSQLite3Database<TSchema>;
-    pglite: PgliteDatabase<TSchema>;
-};
-type Primitive = string | number | boolean | undefined | null;
-type ClientInstanceMap = {
-    'node-postgres': NodePgPool;
-    'postgres-js': PostgresJsClient;
-    'neon-websocket': NeonServerlessPool;
-    'neon-http': NeonQueryFunction<boolean, boolean>;
-    'vercel-postgres': VercelPool & (<O extends QueryResultRow>(strings: TemplateStringsArray, ...values: Primitive[]) => Promise<QueryResult<O>>);
-    'aws-data-api-pg': RDSDataClient;
-    planetscale: PlanetscaleClient;
-    mysql2: Mysql2Pool;
-    'tidb-serverless': TiDBConnection;
-    libsql: LibsqlClient;
-    turso: LibsqlClient;
-    d1: AnyD1Database;
-    'bun:sqlite': BunDatabase;
-    'better-sqlite3': BetterSQLite3Database;
-    pglite: PGlite;
-};
-type ClientTypeImportErrorMap = {
-    'node-postgres': 'pg`, `@types/pg';
-    'postgres-js': 'postgres';
-    'neon-websocket': '@neondatabase/serverless';
-    'neon-http': '@neondatabase/serverless';
-    'vercel-postgres': '@vercel/postgres';
-    'aws-data-api-pg': '@aws-sdk/client-rds-data';
-    planetscale: '@planetscale/database';
-    mysql2: 'mysql2';
-    'tidb-serverless': '@tidbcloud/serverless';
-    libsql: '@libsql/client';
-    turso: '@libsql/client';
-    d1: '@cloudflare/workers-types` or `@miniflare/d1';
-    'bun:sqlite': 'bun-types';
-    'better-sqlite3': 'better-sqlite3';
-    pglite: '@electric-sql/pglite';
-};
-type ImportTypeError<TClient extends DatabaseClient> = `Please install \`${ClientTypeImportErrorMap[TClient]}\`to allow Drizzle ORM to connect to the database`;
-type InitializerParams = {
-    'node-postgres': {
-        connection: string | NodePgPoolConfig;
-    };
-    'postgres-js': {
-        connection: string | ({
-            url?: string;
-        } & PostgresJSOptions<Record<string, PostgresJSPostgresType>>);
-    };
-    'neon-websocket': {
-        connection: string | NeonServerlessConfig;
-    };
-    'neon-http': {
-        connection: MonodriverNeonHttpConfig;
-    };
-    'vercel-postgres': {};
-    'aws-data-api-pg': {
-        connection: AwsDataApiConnectionConfig;
-    };
-    planetscale: {
-        connection: PlanetscaleConfig | string;
-    };
-    mysql2: {
-        connection: Mysql2Config | string;
-    };
-    'tidb-serverless': {
-        connection: TiDBServerlessConfig | string;
-    };
-    libsql: {
-        connection: LibsqlConfig | string;
-    };
-    turso: {
-        connection: LibsqlConfig | string;
-    };
-    d1: {
-        connection: AnyD1Database;
-    };
-    'bun:sqlite': {
-        connection?: BunSqliteDatabaseConfig;
-    };
-    'better-sqlite3': {
-        connection?: BetterSQLite3DatabaseConfig;
-    };
-    pglite: {
-        connection?: (PGliteOptions & {
-            dataDir?: string;
-        }) | string;
-    };
-};
-type DetermineClient<TClient extends DatabaseClient, TSchema extends Record<string, unknown>> = ClientDrizzleInstanceMap<TSchema>[TClient] & {
-    $client: ClientInstanceMap[TClient];
-};
-export declare function drizzle<TClient extends DatabaseClient, TSchema extends Record<string, unknown> = Record<string, never>>(client: TClient, ...params: TClient extends 'bun:sqlite' | 'better-sqlite3' | 'pglite' ? ([
-] | [
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-] | [string]) : TClient extends 'vercel-postgres' ? ([] | [
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-]) : TClient extends 'postgres-js' | 'tidb-serverless' | 'libsql' | 'turso' | 'planetscale' | 'neon-http' | 'node-postgres' ? ([
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-] | [string]) : TClient extends 'mysql2' ? ([
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & MySql2DrizzleConfig<TSchema>)
-] | [string]) : TClient extends 'neon-websocket' ? ([
-    IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema> & {
-        ws?: any;
-    }
-] | [string]) : [
-    (IfNotImported<ClientInstanceMap[TClient], {
-        connection: ImportTypeError<TClient>;
-    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
-]): Promise<DetermineClient<TClient, TSchema>>;
-export {};

package/monodriver.js

@@ -1,249 +0,0 @@
-const importError = (libName) => {
-  throw new Error(
-    `Please install '${libName}' to allow Drizzle ORM to connect to the database`
-  );
-};
-function assertUnreachable(_) {
-  throw new Error("Didn't expect to get here");
-}
-async function drizzle(client, ...params) {
-  switch (client) {
-    case "node-postgres": {
-      const defpg = await import("pg").catch(() => importError("pg"));
-      const { drizzle: drizzle2 } = await import("./node-postgres/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        const instance2 = typeof connection === "string" ? new defpg.default.Pool({
-          connectionString: connection
-        }) : new defpg.default.Pool(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = typeof params[0] === "string" ? new defpg.default.Pool({
-        connectionString: params[0]
-      }) : new defpg.default.Pool(params[0]);
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "aws-data-api-pg": {
-      const { connection, ...drizzleConfig } = params[0];
-      const { resourceArn, database, secretArn, ...rdsConfig } = connection;
-      const { RDSDataClient } = await import("@aws-sdk/client-rds-data").catch(
-        () => importError("@aws-sdk/client-rds-data")
-      );
-      const { drizzle: drizzle2 } = await import("./aws-data-api/pg/index.js");
-      const instance = new RDSDataClient(rdsConfig);
-      const db = drizzle2(instance, { resourceArn, database, secretArn, ...drizzleConfig });
-      return db;
-    }
-    case "better-sqlite3": {
-      const { default: Client } = await import("better-sqlite3").catch(() => importError("better-sqlite3"));
-      const { drizzle: drizzle2 } = await import("./better-sqlite3/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        if (typeof connection === "object") {
-          const { source, ...options } = connection;
-          const instance3 = new Client(source, options);
-          const db3 = drizzle2(instance3, drizzleConfig);
-          return db3;
-        }
-        const instance2 = new Client(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = new Client(params[0]);
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "bun:sqlite": {
-      const { Database: Client } = await import("bun:sqlite").catch(() => {
-        throw new Error(`Please use bun to use 'bun:sqlite' for Drizzle ORM to connect to database`);
-      });
-      const { drizzle: drizzle2 } = await import("./bun-sqlite/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        if (typeof connection === "object") {
-          const { source, ...opts } = connection;
-          const options = Object.values(opts).filter((v) => v !== void 0).length ? opts : void 0;
-          const instance3 = new Client(source, options);
-          const db3 = drizzle2(instance3, drizzleConfig);
-          return db3;
-        }
-        const instance2 = new Client(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = new Client(params[0]);
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "d1": {
-      const { connection, ...drizzleConfig } = params[0];
-      const { drizzle: drizzle2 } = await import("./d1/index.js");
-      const db = drizzle2(connection, drizzleConfig);
-      return db;
-    }
-    case "libsql":
-    case "turso": {
-      const { createClient } = await import("@libsql/client").catch(() => importError("@libsql/client"));
-      const { drizzle: drizzle2 } = await import("./libsql/index.js");
-      if (typeof params[0] === "string") {
-        const instance2 = createClient({
-          url: params[0]
-        });
-        const db2 = drizzle2(instance2);
-        return db2;
-      }
-      const { connection, ...drizzleConfig } = params[0];
-      const instance = typeof connection === "string" ? createClient({ url: connection }) : createClient(connection);
-      const db = drizzle2(instance, drizzleConfig);
-      return db;
-    }
-    case "mysql2": {
-      const { createPool } = await import("mysql2/promise").catch(() => importError("mysql2"));
-      const { drizzle: drizzle2 } = await import("./mysql2/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        const instance2 = createPool(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const connectionString = params[0];
-      const instance = createPool(connectionString);
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "neon-http": {
-      const { neon } = await import("@neondatabase/serverless").catch(() => importError("@neondatabase/serverless"));
-      const { drizzle: drizzle2 } = await import("./neon-http/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        if (typeof connection === "object") {
-          const { connectionString, ...options } = connection;
-          const instance3 = neon(connectionString, options);
-          const db3 = drizzle2(instance3, drizzleConfig);
-          return db3;
-        }
-        const instance2 = neon(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = neon(params[0]);
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "neon-websocket": {
-      const { Pool, neonConfig } = await import("@neondatabase/serverless").catch(
-        () => importError("@neondatabase/serverless")
-      );
-      const { drizzle: drizzle2 } = await import("./neon-serverless/index.js");
-      if (typeof params[0] === "string") {
-        const instance2 = new Pool({
-          connectionString: params[0]
-        });
-        const db2 = drizzle2(instance2);
-        return db2;
-      }
-      if (typeof params[0] === "object") {
-        const { connection, ws, ...drizzleConfig } = params[0];
-        if (ws) {
-          neonConfig.webSocketConstructor = ws;
-        }
-        const instance2 = typeof connection === "string" ? new Pool({
-          connectionString: connection
-        }) : new Pool(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = new Pool();
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "planetscale": {
-      const { Client } = await import("@planetscale/database").catch(() => importError("@planetscale/database"));
-      const { drizzle: drizzle2 } = await import("./planetscale-serverless/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        const instance2 = typeof connection === "string" ? new Client({
-          url: connection
-        }) : new Client(
-          connection
-        );
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = new Client({
-        url: params[0]
-      });
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "postgres-js": {
-      const { default: client2 } = await import("postgres").catch(() => importError("postgres"));
-      const { drizzle: drizzle2 } = await import("./postgres-js/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        if (typeof connection === "object" && connection.url !== void 0) {
-          const { url, ...config } = connection;
-          const instance3 = client2(url, config);
-          const db3 = drizzle2(instance3, drizzleConfig);
-          return db3;
-        }
-        const instance2 = client2(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = client2(params[0]);
-      const db = drizzle2(instance);
-      return db;
-    }
-    case "tidb-serverless": {
-      const { connect } = await import("@tidbcloud/serverless").catch(() => importError("@tidbcloud/serverless"));
-      const { drizzle: drizzle2 } = await import("./tidb-serverless/index.js");
-      if (typeof params[0] === "string") {
-        const instance2 = connect({
-          url: params[0]
-        });
-        const db2 = drizzle2(instance2);
-        return db2;
-      }
-      const { connection, ...drizzleConfig } = params[0];
-      const instance = typeof connection === "string" ? connect({
-        url: connection
-      }) : connect(connection);
-      const db = drizzle2(instance, drizzleConfig);
-      return db;
-    }
-    case "vercel-postgres": {
-      const drizzleConfig = params[0];
-      const { sql } = await import("@vercel/postgres").catch(() => importError("@vercel/postgres"));
-      const { drizzle: drizzle2 } = await import("./vercel-postgres/index.js");
-      const db = drizzle2(sql, drizzleConfig);
-      return db;
-    }
-    case "pglite": {
-      const { PGlite } = await import("@electric-sql/pglite").catch(() => importError("@electric-sql/pglite"));
-      const { drizzle: drizzle2 } = await import("./pglite/index.js");
-      if (typeof params[0] === "object") {
-        const { connection, ...drizzleConfig } = params[0];
-        if (typeof connection === "object") {
-          const { dataDir, ...options } = connection;
-          const instance3 = new PGlite(dataDir, options);
-          const db3 = drizzle2(instance3, drizzleConfig);
-          return db3;
-        }
-        const instance2 = new PGlite(connection);
-        const db2 = drizzle2(instance2, drizzleConfig);
-        return db2;
-      }
-      const instance = new PGlite(params[0]);
-      const db = drizzle2(instance);
-      return db;
-    }
-  }
-  assertUnreachable(client);
-}
-export {
-  drizzle
-};
-//# sourceMappingURL=monodriver.js.map