drizzle-orm 0.33.0-cd1f68c → 0.33.0-d11d7bb

package/monodriver.d.cts

@@ -1,6 +1,5 @@
-/// <reference types="@cloudflare/workers-types" />
-/// <reference types="node" />
 /// <reference types="bun-types" />
+/// <reference types="node" />
 import type { RDSDataClient, RDSDataClientConfig as RDSConfig } from '@aws-sdk/client-rds-data';
 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';
@@ -10,21 +9,23 @@ 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 { DrizzleD1Database } from "./d1/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 { 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 } from "./utils.cjs";
+import type { DrizzleConfig, IfNotImported } from "./utils.cjs";
 import type { VercelPgDatabase } from "./vercel-postgres/index.cjs";
-type BunSqliteDatabaseOptions = number | {
+type BunSqliteDatabaseOptions = {
     /**
      * Open the database as read-only (no write operations, no create).
      *
@@ -44,22 +45,21 @@ type BunSqliteDatabaseOptions = number | {
      */
     readwrite?: boolean;
 };
-type BunSqliteDatabaseConfig = {
-    filename?: ':memory:' | (string & {});
-    options?: BunSqliteDatabaseOptions;
-} | ':memory:' | (string & {}) | undefined;
-type BetterSQLite3DatabaseConfig = {
-    filename?: ':memory:' | (string & {}) | Buffer;
-    options?: BetterSQLite3Options;
-} | ':memory:' | (string & {}) | undefined;
-type MonodriverNeonHttpConfig = {
+type BunSqliteDatabaseConfig = ({
+    source?: string;
+} & BunSqliteDatabaseOptions) | string | undefined;
+type BetterSQLite3DatabaseConfig = ({
+    source?: string | Buffer;
+} & BetterSQLite3Options) | string | undefined;
+type MonodriverNeonHttpConfig = ({
     connectionString: string;
-    options?: NeonHttpConfig<boolean, boolean>;
-} | string;
-type DatabaseClient = 'postgres-js' | 'neon-serverless' | 'neon-http' | 'vercel-postgres' | 'aws-data-api-pg' | 'planetscale' | 'mysql2' | 'tidb-serverless' | 'libsql' | 'turso' | 'd1' | 'bun:sqlite' | 'better-sqlite3';
+} & 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';
 type ClientDrizzleInstanceMap<TSchema extends Record<string, any>> = {
+    'node-postgres': NodePgDatabase<TSchema>;
     'postgres-js': PostgresJsDatabase<TSchema>;
-    'neon-serverless': NeonDatabase<TSchema>;
+    'neon-websocket': NeonDatabase<TSchema>;
     'neon-http': NeonHttpDatabase<TSchema>;
     'vercel-postgres': VercelPgDatabase<TSchema>;
     'aws-data-api-pg': AwsDataApiPgDatabase<TSchema>;
@@ -74,8 +74,9 @@ type ClientDrizzleInstanceMap<TSchema extends Record<string, any>> = {
 };
 type Primitive = string | number | boolean | undefined | null;
 type ClientInstanceMap = {
+    'node-postgres': NodePgPool;
     'postgres-js': PostgresJsClient;
-    'neon-serverless': NeonServerlessPool;
+    '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;
@@ -84,23 +85,45 @@ type ClientInstanceMap = {
     'tidb-serverless': TiDBConnection;
     libsql: LibsqlClient;
     turso: LibsqlClient;
-    d1: D1Database;
+    d1: AnyD1Database;
     'bun:sqlite': BunDatabase;
     'better-sqlite3': BetterSQLite3Database;
 };
+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';
+};
+type ImportTypeError<TClient extends DatabaseClient> = `Please install \`${ClientTypeImportErrorMap[TClient]}\` for Drizzle ORM to connect to database`;
 type InitializerParams = {
+    'node-postgres': {
+        connection: string | NodePgPoolConfig;
+    };
     'postgres-js': {
-        connection: string | PostgresJSOptions<Record<string, PostgresJSPostgresType>>;
+        connection: string | ({
+            url?: string;
+        } & PostgresJSOptions<Record<string, PostgresJSPostgresType>>);
     };
-    'neon-serverless': {
-        connection?: string | NeonServerlessConfig;
+    'neon-websocket': {
+        connection: string | NeonServerlessConfig;
     };
     'neon-http': {
         connection: MonodriverNeonHttpConfig;
     };
     'vercel-postgres': {};
     'aws-data-api-pg': {
-        connection?: RDSConfig;
+        connection: AwsDataApiConnectionConfig;
     };
     planetscale: {
         connection: PlanetscaleConfig | string;
@@ -118,7 +141,7 @@ type InitializerParams = {
         connection: LibsqlConfig | string;
     };
     d1: {
-        connection: D1Database;
+        connection: AnyD1Database;
     };
     'bun:sqlite': {
         connection?: BunSqliteDatabaseConfig;
@@ -132,32 +155,30 @@ type DetermineClient<TClient extends DatabaseClient, TSchema extends Record<stri
 };
 export declare function drizzle<TClient extends DatabaseClient, TSchema extends Record<string, unknown> = Record<string, never>>(client: TClient, ...params: TClient extends 'bun:sqlite' | 'better-sqlite3' ? ([
 ] | [
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
-] | [
-    ':memory:'
-] | [
-    (string & {})
-]) : TClient extends 'vercel-postgres' ? ([] | [
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
-]) : TClient extends 'postgres-js' | 'tidb-serverless' | 'libsql' | 'turso' | 'planetscale' ? ([
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
-] | [
-    string
-]) : TClient extends 'mysql2' ? ([
-    (InitializerParams[TClient] & MySql2DrizzleConfig<TSchema>)
-] | [
-    string
-]) : TClient extends 'aws-data-api-pg' ? [
-    InitializerParams[TClient] & DrizzleAwsDataApiPgConfig<TSchema>
-] : TClient extends 'neon-serverless' ? ([
-    InitializerParams[TClient] & DrizzleConfig<TSchema> & {
+    (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] | []) : TClient extends 'neon-http' ? ([
-    InitializerParams[TClient] & DrizzleConfig<TSchema>
-] | [
-    string
-]) : [
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
+] | [string]) : [
+    (IfNotImported<ClientInstanceMap[TClient], {
+        connection: ImportTypeError<TClient>;
+    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
 ]): Promise<DetermineClient<TClient, TSchema>>;
 export {};

package/monodriver.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="@cloudflare/workers-types" />
-/// <reference types="node" />
 /// <reference types="bun-types" />
+/// <reference types="node" />
 import type { RDSDataClient, RDSDataClientConfig as RDSConfig } from '@aws-sdk/client-rds-data';
 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';
@@ -10,21 +9,23 @@ 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 { DrizzleD1Database } from "./d1/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 { 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 } from "./utils.js";
+import type { DrizzleConfig, IfNotImported } from "./utils.js";
 import type { VercelPgDatabase } from "./vercel-postgres/index.js";
-type BunSqliteDatabaseOptions = number | {
+type BunSqliteDatabaseOptions = {
     /**
      * Open the database as read-only (no write operations, no create).
      *
@@ -44,22 +45,21 @@ type BunSqliteDatabaseOptions = number | {
      */
     readwrite?: boolean;
 };
-type BunSqliteDatabaseConfig = {
-    filename?: ':memory:' | (string & {});
-    options?: BunSqliteDatabaseOptions;
-} | ':memory:' | (string & {}) | undefined;
-type BetterSQLite3DatabaseConfig = {
-    filename?: ':memory:' | (string & {}) | Buffer;
-    options?: BetterSQLite3Options;
-} | ':memory:' | (string & {}) | undefined;
-type MonodriverNeonHttpConfig = {
+type BunSqliteDatabaseConfig = ({
+    source?: string;
+} & BunSqliteDatabaseOptions) | string | undefined;
+type BetterSQLite3DatabaseConfig = ({
+    source?: string | Buffer;
+} & BetterSQLite3Options) | string | undefined;
+type MonodriverNeonHttpConfig = ({
     connectionString: string;
-    options?: NeonHttpConfig<boolean, boolean>;
-} | string;
-type DatabaseClient = 'postgres-js' | 'neon-serverless' | 'neon-http' | 'vercel-postgres' | 'aws-data-api-pg' | 'planetscale' | 'mysql2' | 'tidb-serverless' | 'libsql' | 'turso' | 'd1' | 'bun:sqlite' | 'better-sqlite3';
+} & 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';
 type ClientDrizzleInstanceMap<TSchema extends Record<string, any>> = {
+    'node-postgres': NodePgDatabase<TSchema>;
     'postgres-js': PostgresJsDatabase<TSchema>;
-    'neon-serverless': NeonDatabase<TSchema>;
+    'neon-websocket': NeonDatabase<TSchema>;
     'neon-http': NeonHttpDatabase<TSchema>;
     'vercel-postgres': VercelPgDatabase<TSchema>;
     'aws-data-api-pg': AwsDataApiPgDatabase<TSchema>;
@@ -74,8 +74,9 @@ type ClientDrizzleInstanceMap<TSchema extends Record<string, any>> = {
 };
 type Primitive = string | number | boolean | undefined | null;
 type ClientInstanceMap = {
+    'node-postgres': NodePgPool;
     'postgres-js': PostgresJsClient;
-    'neon-serverless': NeonServerlessPool;
+    '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;
@@ -84,23 +85,45 @@ type ClientInstanceMap = {
     'tidb-serverless': TiDBConnection;
     libsql: LibsqlClient;
     turso: LibsqlClient;
-    d1: D1Database;
+    d1: AnyD1Database;
     'bun:sqlite': BunDatabase;
     'better-sqlite3': BetterSQLite3Database;
 };
+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';
+};
+type ImportTypeError<TClient extends DatabaseClient> = `Please install \`${ClientTypeImportErrorMap[TClient]}\` for Drizzle ORM to connect to database`;
 type InitializerParams = {
+    'node-postgres': {
+        connection: string | NodePgPoolConfig;
+    };
     'postgres-js': {
-        connection: string | PostgresJSOptions<Record<string, PostgresJSPostgresType>>;
+        connection: string | ({
+            url?: string;
+        } & PostgresJSOptions<Record<string, PostgresJSPostgresType>>);
     };
-    'neon-serverless': {
-        connection?: string | NeonServerlessConfig;
+    'neon-websocket': {
+        connection: string | NeonServerlessConfig;
     };
     'neon-http': {
         connection: MonodriverNeonHttpConfig;
     };
     'vercel-postgres': {};
     'aws-data-api-pg': {
-        connection?: RDSConfig;
+        connection: AwsDataApiConnectionConfig;
     };
     planetscale: {
         connection: PlanetscaleConfig | string;
@@ -118,7 +141,7 @@ type InitializerParams = {
         connection: LibsqlConfig | string;
     };
     d1: {
-        connection: D1Database;
+        connection: AnyD1Database;
     };
     'bun:sqlite': {
         connection?: BunSqliteDatabaseConfig;
@@ -132,32 +155,30 @@ type DetermineClient<TClient extends DatabaseClient, TSchema extends Record<stri
 };
 export declare function drizzle<TClient extends DatabaseClient, TSchema extends Record<string, unknown> = Record<string, never>>(client: TClient, ...params: TClient extends 'bun:sqlite' | 'better-sqlite3' ? ([
 ] | [
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
-] | [
-    ':memory:'
-] | [
-    (string & {})
-]) : TClient extends 'vercel-postgres' ? ([] | [
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
-]) : TClient extends 'postgres-js' | 'tidb-serverless' | 'libsql' | 'turso' | 'planetscale' ? ([
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
-] | [
-    string
-]) : TClient extends 'mysql2' ? ([
-    (InitializerParams[TClient] & MySql2DrizzleConfig<TSchema>)
-] | [
-    string
-]) : TClient extends 'aws-data-api-pg' ? [
-    InitializerParams[TClient] & DrizzleAwsDataApiPgConfig<TSchema>
-] : TClient extends 'neon-serverless' ? ([
-    InitializerParams[TClient] & DrizzleConfig<TSchema> & {
+    (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] | []) : TClient extends 'neon-http' ? ([
-    InitializerParams[TClient] & DrizzleConfig<TSchema>
-] | [
-    string
-]) : [
-    (InitializerParams[TClient] & DrizzleConfig<TSchema>)
+] | [string]) : [
+    (IfNotImported<ClientInstanceMap[TClient], {
+        connection: ImportTypeError<TClient>;
+    }, InitializerParams[TClient]> & DrizzleConfig<TSchema>)
 ]): Promise<DetermineClient<TClient, TSchema>>;
 export {};

package/monodriver.js

@@ -8,15 +8,32 @@ function assertUnreachable(_) {
 }
 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");
+      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");
-      const instance = connection ? new RDSDataClient(connection) : new RDSDataClient();
-      const db = drizzle2(instance, drizzleConfig);
-      db.$client = instance;
+      const instance = new RDSDataClient(rdsConfig);
+      const db = drizzle2(instance, { resourceArn, database, secretArn, ...drizzleConfig });
       return db;
     }
     case "better-sqlite3": {
@@ -25,49 +42,45 @@ async function drizzle(client, ...params) {
       if (typeof params[0] === "object") {
         const { connection, ...drizzleConfig } = params[0];
         if (typeof connection === "object") {
-          const { filename, options } = connection;
-          const instance3 = new Client(filename, options);
+          const { source, ...options } = connection;
+          const instance3 = new Client(source, options);
           const db3 = drizzle2(instance3, drizzleConfig);
-          db3.$client = instance3;
           return db3;
         }
         const instance2 = new Client(connection);
         const db2 = drizzle2(instance2, drizzleConfig);
-        db2.$client = instance2;
         return db2;
       }
       const instance = new Client(params[0]);
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
     case "bun:sqlite": {
-      const { Database: Client } = await import("bun:sqlite").catch(() => importError("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");
       if (typeof params[0] === "object") {
         const { connection, ...drizzleConfig } = params[0];
         if (typeof connection === "object") {
-          const { filename, options } = connection;
-          const instance3 = new Client(filename, options);
+          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);
-          db3.$client = instance3;
           return db3;
         }
         const instance2 = new Client(connection);
         const db2 = drizzle2(instance2, drizzleConfig);
-        db2.$client = instance2;
         return db2;
       }
       const instance = new Client(params[0]);
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
     case "d1": {
       const { connection, ...drizzleConfig } = params[0];
       const { drizzle: drizzle2 } = await import("./d1");
       const db = drizzle2(connection, drizzleConfig);
-      db.$client = connection;
       return db;
     }
     case "libsql":
@@ -79,29 +92,25 @@ async function drizzle(client, ...params) {
           url: params[0]
         });
         const db2 = drizzle2(instance2);
-        db2.$client = instance2;
         return db2;
       }
       const { connection, ...drizzleConfig } = params[0];
       const instance = typeof connection === "string" ? createClient({ url: connection }) : createClient(connection);
       const db = drizzle2(instance, drizzleConfig);
-      db.$client = instance;
       return db;
     }
     case "mysql2": {
-      const { createPool } = await import("mysql2/promise").catch(() => importError("mysql2/promise"));
+      const { createPool } = await import("mysql2/promise").catch(() => importError("mysql2"));
       const { drizzle: drizzle2 } = await import("./mysql2");
       if (typeof params[0] === "object") {
         const { connection, ...drizzleConfig } = params[0];
         const instance2 = createPool(connection);
         const db2 = drizzle2(instance2, drizzleConfig);
-        db2.$client = instance2;
         return db2;
       }
       const connectionString = params[0];
       const instance = createPool(connectionString);
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
     case "neon-http": {
@@ -110,23 +119,20 @@ async function drizzle(client, ...params) {
       if (typeof params[0] === "object") {
         const { connection, ...drizzleConfig } = params[0];
         if (typeof connection === "object") {
-          const { connectionString, options } = connection;
+          const { connectionString, ...options } = connection;
           const instance3 = neon(connectionString, options);
           const db3 = drizzle2(instance3, drizzleConfig);
-          db3.$client = instance3;
           return db3;
         }
         const instance2 = neon(connection);
         const db2 = drizzle2(instance2, drizzleConfig);
-        db2.$client = instance2;
         return db2;
       }
       const instance = neon(params[0]);
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
-    case "neon-serverless": {
+    case "neon-websocket": {
       const { Pool, neonConfig } = await import("@neondatabase/serverless").catch(
         () => importError("@neondatabase/serverless")
       );
@@ -136,7 +142,6 @@ async function drizzle(client, ...params) {
           connectionString: params[0]
         });
         const db2 = drizzle2(instance2);
-        db2.$client = instance2;
         return db2;
       }
       if (typeof params[0] === "object") {
@@ -148,12 +153,10 @@ async function drizzle(client, ...params) {
           connectionString: connection
         }) : new Pool(connection);
         const db2 = drizzle2(instance2, drizzleConfig);
-        db2.$client = instance2;
         return db2;
       }
       const instance = new Pool();
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
     case "planetscale": {
@@ -167,14 +170,12 @@ async function drizzle(client, ...params) {
           connection
         );
         const db2 = drizzle2(instance2, drizzleConfig);
-        db2.$client = instance2;
         return db2;
       }
       const instance = new Client({
         url: params[0]
       });
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
     case "postgres-js": {
@@ -182,14 +183,18 @@ async function drizzle(client, ...params) {
       const { drizzle: drizzle2 } = await import("./postgres-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);
-        db2.$client = instance2;
         return db2;
       }
       const instance = client2(params[0]);
       const db = drizzle2(instance);
-      db.$client = instance;
       return db;
     }
     case "tidb-serverless": {
@@ -200,7 +205,6 @@ async function drizzle(client, ...params) {
           url: params[0]
         });
         const db2 = drizzle2(instance2);
-        db2.$client = instance2;
         return db2;
       }
       const { connection, ...drizzleConfig } = params[0];
@@ -208,7 +212,6 @@ async function drizzle(client, ...params) {
         url: connection
       }) : connect(connection);
       const db = drizzle2(instance, drizzleConfig);
-      db.$client = instance;
       return db;
     }
     case "vercel-postgres": {
@@ -216,7 +219,6 @@ async function drizzle(client, ...params) {
       const { sql } = await import("@vercel/postgres").catch(() => importError("@vercel/postgres"));
       const { drizzle: drizzle2 } = await import("./vercel-postgres");
       const db = drizzle2(sql, drizzleConfig);
-      db.$client = sql;
       return db;
     }
   }