@leonardovida-md/drizzle-neo-duckdb 1.0.3 → 1.1.0

package/README.md

@@ -7,7 +7,7 @@
 [![npm version](https://img.shields.io/npm/v/@leonardovida-md/drizzle-neo-duckdb)](https://www.npmjs.com/package/@leonardovida-md/drizzle-neo-duckdb)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
-[Documentation](https://leonardovida-md.github.io/drizzle-neo-duckdb/) • [Examples](./example) • [Contributing](#contributing)
+[Documentation](https://leonardovida.github.io/drizzle-neo-duckdb/) • [LLM Context](https://leonardovida.github.io/drizzle-neo-duckdb/llms.txt) • [Examples](./example) • [Contributing](#contributing)
 
 </div>
 
@@ -19,6 +19,8 @@ Works with local DuckDB files, in-memory databases, and [MotherDuck](https://mot
 
 > **Status:** Experimental. Core query building, migrations, and type inference work well. Some DuckDB-specific types and edge cases are still being refined.
 
+Docs tip: every docs page has a **Markdown (raw)** button for LLM-friendly source.
+
 ## Installation
 
 ```bash
@@ -188,7 +190,20 @@ const products = pgTable('products', {
 });
 ```
 
-See [Column Types Documentation](https://leonardovida-md.github.io/drizzle-neo-duckdb/api/columns) for complete reference.
+See [Column Types Documentation](https://leonardovida.github.io/drizzle-neo-duckdb/api/columns) for complete reference.
+
+### Client-Safe Imports (schemas, drizzle-zod, trpc)
+
+When generated schemas are consumed in client bundles, import the helpers from the browser-safe subpath to avoid pulling the native DuckDB bindings:
+
+```typescript
+import {
+  duckDbJson,
+  duckDbList,
+} from '@leonardovida-md/drizzle-neo-duckdb/helpers';
+```
+
+The introspection CLI now emits this import path by default. You can still override `importBasePath` if you need the old root import.
 
 ## Querying
 
@@ -275,7 +290,7 @@ import { migrate } from '@leonardovida-md/drizzle-neo-duckdb';
 await migrate(db, { migrationsFolder: './drizzle' });
 ```
 
-Migration metadata is stored in `drizzle.__drizzle_migrations` by default. See [Migrations Documentation](https://leonardovida-md.github.io/drizzle-neo-duckdb/guide/migrations) for configuration options.
+Migration metadata is stored in `drizzle.__drizzle_migrations` by default. See [Migrations Documentation](https://leonardovida.github.io/drizzle-neo-duckdb/guide/migrations) for configuration options.
 
 ## Schema Introspection
 
@@ -300,7 +315,7 @@ const result = await introspect(db, {
 console.log(result.files.schemaTs);
 ```
 
-See [Introspection Documentation](https://leonardovida-md.github.io/drizzle-neo-duckdb/guide/introspection) for all options.
+See [Introspection Documentation](https://leonardovida.github.io/drizzle-neo-duckdb/guide/introspection) for all options.
 
 ## Configuration Options
 
@@ -333,7 +348,7 @@ This connector aims for compatibility with Drizzle's Postgres driver but has som
 | Prepared statements   | No statement caching                                       |
 | Streaming results     | Materialized by default; use `executeBatches()` for chunks |
 
-See [Limitations Documentation](https://leonardovida-md.github.io/drizzle-neo-duckdb/guide/limitations) for details.
+See [Limitations Documentation](https://leonardovida.github.io/drizzle-neo-duckdb/guide/limitations) for details.
 
 ## Examples
 

package/dist/client.d.ts

@@ -1,6 +1,12 @@
 import { type DuckDBConnection } from '@duckdb/node-api';
-export type DuckDBClientLike = DuckDBConnection;
+export type DuckDBClientLike = DuckDBConnection | DuckDBConnectionPool;
 export type RowData = Record<string, unknown>;
+export interface DuckDBConnectionPool {
+    acquire(): Promise<DuckDBConnection>;
+    release(connection: DuckDBConnection): void | Promise<void>;
+    close?(): Promise<void> | void;
+}
+export declare function isPool(client: DuckDBClientLike): client is DuckDBConnectionPool;
 export interface PrepareParamsOptions {
     rejectStringArrayLiterals?: boolean;
     warnOnStringArrayLiteral?: () => void;

package/dist/columns.d.ts

@@ -1,6 +1,6 @@
 import { type SQL } from 'drizzle-orm';
 import type { SQLWrapper } from 'drizzle-orm/sql/sql';
-import { type ListValueWrapper, type ArrayValueWrapper, type MapValueWrapper, type BlobValueWrapper, type JsonValueWrapper } from './value-wrappers.ts';
+import { type ListValueWrapper, type ArrayValueWrapper, type MapValueWrapper, type BlobValueWrapper, type JsonValueWrapper } from './value-wrappers-core.ts';
 type IntColType = 'SMALLINT' | 'INTEGER' | 'BIGINT' | 'HUGEINT' | 'USMALLINT' | 'UINTEGER' | 'UBIGINT' | 'UHUGEINT' | 'INT' | 'INT16' | 'INT32' | 'INT64' | 'INT128' | 'LONG' | 'VARINT';
 type FloatColType = 'FLOAT' | 'DOUBLE';
 type StringColType = 'STRING' | 'VARCHAR' | 'TEXT';

package/dist/driver.d.ts

@@ -1,3 +1,4 @@
+import { DuckDBInstance } from '@duckdb/node-api';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { PgDatabase } from 'drizzle-orm/pg-core/db';
@@ -10,6 +11,7 @@ import { DuckDBSession } from './session.ts';
 import { DuckDBDialect } from './dialect.ts';
 import { DuckDBSelectBuilder } from './select-builder.ts';
 import type { ExecuteInBatchesOptions, RowData } from './client.ts';
+import { type DuckDBPoolConfig, type PoolPreset } from './pool.ts';
 export interface PgDriverOptions {
     logger?: Logger;
     rewriteArrays?: boolean;
@@ -23,16 +25,46 @@ export declare class DuckDBDriver {
     constructor(client: DuckDBClientLike, dialect: DuckDBDialect, options?: PgDriverOptions);
     createSession(schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined): DuckDBSession<Record<string, unknown>, TablesRelationalConfig>;
 }
+/** Connection configuration when using path-based connection */
+export interface DuckDBConnectionConfig {
+    /** Database path: ':memory:', './file.duckdb', 'md:', 'md:database' */
+    path: string;
+    /** DuckDB instance options (e.g., motherduck_token) */
+    options?: Record<string, string>;
+}
 export interface DuckDBDrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> extends DrizzleConfig<TSchema> {
     rewriteArrays?: boolean;
     rejectStringArrayLiterals?: boolean;
+    /** Pool configuration. Use preset name, size config, or false to disable. */
+    pool?: DuckDBPoolConfig | PoolPreset | false;
+}
+export interface DuckDBDrizzleConfigWithConnection<TSchema extends Record<string, unknown> = Record<string, never>> extends DuckDBDrizzleConfig<TSchema> {
+    /** Connection string or config object */
+    connection: string | DuckDBConnectionConfig;
+}
+export interface DuckDBDrizzleConfigWithClient<TSchema extends Record<string, unknown> = Record<string, never>> extends DuckDBDrizzleConfig<TSchema> {
+    /** Explicit client (connection or pool) */
+    client: DuckDBClientLike;
 }
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(connectionString: string): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(connectionString: string, config: DuckDBDrizzleConfig<TSchema>): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DuckDBDrizzleConfigWithConnection<TSchema>): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DuckDBDrizzleConfigWithClient<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
 export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: DuckDBClientLike, config?: DuckDBDrizzleConfig<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
 export declare class DuckDBDatabase<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends PgDatabase<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     readonly dialect: DuckDBDialect;
     readonly session: DuckDBSession<TFullSchema, TSchema>;
     static readonly [entityKind]: string;
-    constructor(dialect: DuckDBDialect, session: DuckDBSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined);
+    /** The underlying connection or pool */
+    readonly $client: DuckDBClientLike;
+    /** The DuckDB instance (when created from connection string) */
+    readonly $instance?: DuckDBInstance;
+    constructor(dialect: DuckDBDialect, session: DuckDBSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined, client: DuckDBClientLike, instance?: DuckDBInstance);
+    /**
+     * Close the database connection pool and instance.
+     * Should be called when shutting down the application.
+     */
+    close(): Promise<void>;
     select(): DuckDBSelectBuilder<undefined>;
     select<TSelection extends SelectedFields>(fields: TSelection): DuckDBSelectBuilder<TSelection>;
     executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<T[], void, void>;

package/dist/duckdb-introspect.mjs

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 // src/bin/duckdb-introspect.ts
-import { DuckDBInstance } from "@duckdb/node-api";
+import { DuckDBInstance as DuckDBInstance3 } from "@duckdb/node-api";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 
 // src/driver.ts
+import { DuckDBInstance as DuckDBInstance2 } from "@duckdb/node-api";
 import { entityKind as entityKind3 } from "drizzle-orm/entity";
 import { DefaultLogger } from "drizzle-orm/logger";
 import { PgDatabase } from "drizzle-orm/pg-core/db";
@@ -23,10 +24,6 @@ import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
 import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
 
 // src/sql/query-rewriters.ts
-var tableIdPropSelectionRegex = new RegExp([
-  `("(.+)"\\."(.+)")`,
-  `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`
-].join(""), "i");
 function adaptArrayOperators(query) {
   const operators = [
     { token: "@>", fn: "array_has_all" },
@@ -43,6 +40,8 @@ function adaptArrayOperators(query) {
     let inString = false;
     for (;idx >= 0; idx--) {
       const ch = source[idx];
+      if (ch === undefined)
+        break;
       if (ch === "'" && source[idx - 1] !== "\\") {
         inString = !inString;
       }
@@ -70,6 +69,8 @@ function adaptArrayOperators(query) {
     let inString = false;
     for (;idx < source.length; idx++) {
       const ch = source[idx];
+      if (ch === undefined)
+        break;
       if (ch === "'" && source[idx - 1] !== "\\") {
         inString = !inString;
       }
@@ -325,7 +326,11 @@ import {
   timestampValue,
   timestampTZValue
 } from "@duckdb/node-api";
+
+// src/value-wrappers-core.ts
 var DUCKDB_VALUE_MARKER = Symbol.for("drizzle-duckdb:value");
+
+// src/value-wrappers.ts
 function dateToMicros(value) {
   if (value instanceof Date) {
     return BigInt(value.getTime()) * 1000n;
@@ -383,6 +388,9 @@ function wrapperToNodeApiValue(wrapper, toValue) {
 }
 
 // src/client.ts
+function isPool(client) {
+  return typeof client.acquire === "function";
+}
 function isPgArrayLiteral(value) {
   return value.startsWith("{") && value.endsWith("}");
 }
@@ -394,15 +402,13 @@ function parsePgArrayLiteral(value) {
     return value;
   }
 }
-var warnedArrayLiteral = false;
 function prepareParams(params, options = {}) {
   return params.map((param) => {
     if (typeof param === "string" && isPgArrayLiteral(param)) {
       if (options.rejectStringArrayLiterals) {
         throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
       }
-      if (!warnedArrayLiteral && options.warnOnStringArrayLiteral) {
-        warnedArrayLiteral = true;
+      if (options.warnOnStringArrayLiteral) {
         options.warnOnStringArrayLiteral();
       }
       return parsePgArrayLiteral(param);
@@ -445,7 +451,28 @@ function mapRowsToObjects(columns, rows) {
     return obj;
   });
 }
+async function closeClientConnection(connection) {
+  if ("close" in connection && typeof connection.close === "function") {
+    await connection.close();
+    return;
+  }
+  if ("closeSync" in connection && typeof connection.closeSync === "function") {
+    connection.closeSync();
+    return;
+  }
+  if ("disconnectSync" in connection && typeof connection.disconnectSync === "function") {
+    connection.disconnectSync();
+  }
+}
 async function executeOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
   const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
   const result = await client.run(query, values);
   const rows = await result.getRowsJS();
@@ -454,6 +481,15 @@ async function executeOnClient(client, query, params) {
   return rows ? mapRowsToObjects(uniqueColumns, rows) : [];
 }
 async function* executeInBatches(client, query, params, options = {}) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      yield* executeInBatches(connection, query, params, options);
+      return;
+    } finally {
+      await client.release(connection);
+    }
+  }
   const rowsPerChunk = options.rowsPerChunk && options.rowsPerChunk > 0 ? options.rowsPerChunk : 1e5;
   const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
   const result = await client.stream(query, values);
@@ -475,6 +511,14 @@ async function* executeInBatches(client, query, params, options = {}) {
   }
 }
 async function executeArrowOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeArrowOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
   const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
   const result = await client.run(query, values);
   const maybeArrow = result.toArrow ?? result.getArrowTable;
@@ -563,16 +607,30 @@ class DuckDBSession extends PgSession {
     return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArrays, this.rejectStringArrayLiterals, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
   }
   async transaction(transaction) {
-    const session = new DuckDBSession(this.client, this.dialect, this.schema, this.options);
+    let pinnedConnection;
+    let pool;
+    let clientForTx = this.client;
+    if (isPool(this.client)) {
+      pool = this.client;
+      pinnedConnection = await pool.acquire();
+      clientForTx = pinnedConnection;
+    }
+    const session = new DuckDBSession(clientForTx, this.dialect, this.schema, this.options);
     const tx = new DuckDBTransaction(this.dialect, session, this.schema);
-    await tx.execute(sql`BEGIN TRANSACTION;`);
     try {
-      const result = await transaction(tx);
-      await tx.execute(sql`commit`);
-      return result;
-    } catch (error) {
-      await tx.execute(sql`rollback`);
-      throw error;
+      await tx.execute(sql`BEGIN TRANSACTION;`);
+      try {
+        const result = await transaction(tx);
+        await tx.execute(sql`commit`);
+        return result;
+      } catch (error) {
+        await tx.execute(sql`rollback`);
+        throw error;
+      }
+    } finally {
+      if (pinnedConnection && pool) {
+        await pool.release(pinnedConnection);
+      }
     }
   }
   warnOnStringArrayLiteral = (query) => {
@@ -820,6 +878,72 @@ class DuckDBSelectBuilder extends PgSelectBuilder {
   }
 }
 
+// src/pool.ts
+import { DuckDBConnection } from "@duckdb/node-api";
+var POOL_PRESETS = {
+  pulse: 4,
+  standard: 6,
+  jumbo: 8,
+  mega: 12,
+  giga: 16,
+  local: 8,
+  memory: 4
+};
+function resolvePoolSize(pool) {
+  if (pool === false)
+    return false;
+  if (pool === undefined)
+    return 4;
+  if (typeof pool === "string")
+    return POOL_PRESETS[pool];
+  return pool.size ?? 4;
+}
+function createDuckDBConnectionPool(instance, options = {}) {
+  const size = options.size && options.size > 0 ? options.size : 4;
+  const idle = [];
+  const waiting = [];
+  let total = 0;
+  let closed = false;
+  const acquire = async () => {
+    if (closed) {
+      throw new Error("DuckDB connection pool is closed");
+    }
+    if (idle.length > 0) {
+      return idle.pop();
+    }
+    if (total < size) {
+      total += 1;
+      return await DuckDBConnection.create(instance);
+    }
+    return await new Promise((resolve) => {
+      waiting.push(resolve);
+    });
+  };
+  const release = async (connection) => {
+    if (closed) {
+      await closeClientConnection(connection);
+      return;
+    }
+    const waiter = waiting.shift();
+    if (waiter) {
+      waiter(connection);
+      return;
+    }
+    idle.push(connection);
+  };
+  const close = async () => {
+    closed = true;
+    const toClose = idle.splice(0, idle.length);
+    await Promise.all(toClose.map((conn) => closeClientConnection(conn)));
+  };
+  return {
+    acquire,
+    release,
+    close,
+    size
+  };
+}
+
 // src/driver.ts
 class DuckDBDriver {
   client;
@@ -839,7 +963,14 @@ class DuckDBDriver {
     });
   }
 }
-function drizzle(client, config = {}) {
+function isConfigObject(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  if (data.constructor?.name !== "Object")
+    return false;
+  return "connection" in data || "client" in data || "pool" in data || "schema" in data || "logger" in data;
+}
+function createFromClient(client, config = {}, instance) {
   const dialect = new DuckDBDialect;
   const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
   let schema;
@@ -857,17 +988,60 @@ function drizzle(client, config = {}) {
     rejectStringArrayLiterals: config.rejectStringArrayLiterals
   });
   const session = driver.createSession(schema);
-  return new DuckDBDatabase(dialect, session, schema);
+  const db = new DuckDBDatabase(dialect, session, schema, client, instance);
+  return db;
+}
+async function createFromConnectionString(path, instanceOptions, config = {}) {
+  const instance = await DuckDBInstance2.create(path, instanceOptions);
+  const poolSize = resolvePoolSize(config.pool);
+  if (poolSize === false) {
+    const connection = await instance.connect();
+    return createFromClient(connection, config, instance);
+  }
+  const pool = createDuckDBConnectionPool(instance, { size: poolSize });
+  return createFromClient(pool, config, instance);
+}
+function drizzle(clientOrConfigOrPath, config) {
+  if (typeof clientOrConfigOrPath === "string") {
+    return createFromConnectionString(clientOrConfigOrPath, undefined, config);
+  }
+  if (isConfigObject(clientOrConfigOrPath)) {
+    const configObj = clientOrConfigOrPath;
+    if ("connection" in configObj) {
+      const connConfig = configObj;
+      const { connection, ...restConfig } = connConfig;
+      if (typeof connection === "string") {
+        return createFromConnectionString(connection, undefined, restConfig);
+      }
+      return createFromConnectionString(connection.path, connection.options, restConfig);
+    }
+    if ("client" in configObj) {
+      const clientConfig = configObj;
+      const { client: clientValue, ...restConfig } = clientConfig;
+      return createFromClient(clientValue, restConfig);
+    }
+    throw new Error("Invalid drizzle config: either connection or client must be provided");
+  }
+  return createFromClient(clientOrConfigOrPath, config);
 }
 
 class DuckDBDatabase extends PgDatabase {
   dialect;
   session;
   static [entityKind3] = "DuckDBDatabase";
-  constructor(dialect, session, schema) {
+  $client;
+  $instance;
+  constructor(dialect, session, schema, client, instance) {
     super(dialect, session, schema);
     this.dialect = dialect;
     this.session = session;
+    this.$client = client;
+    this.$instance = instance;
+  }
+  async close() {
+    if (isPool(this.$client) && this.$client.close) {
+      await this.$client.close();
+    }
   }
   select(fields) {
     const selectedFields = fields ? aliasFields(fields) : undefined;
@@ -891,7 +1065,7 @@ class DuckDBDatabase extends PgDatabase {
 // src/introspect.ts
 import { sql as sql4 } from "drizzle-orm";
 var SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog"]);
-var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb";
+var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb/helpers";
 async function introspect(db, opts = {}) {
   const database = await resolveDatabase(db, opts.database, opts.allDatabases);
   const schemas = await resolveSchemas(db, database, opts.schemas);
@@ -1227,6 +1401,22 @@ function mapDuckDbType(column, imports, options) {
     imports.pgCore.add("doublePrecision");
     return { builder: `doublePrecision(${columnName(column.name)})` };
   }
+  const arrayMatch = /^(.*)\[(\d+)\]$/.exec(upper);
+  if (arrayMatch) {
+    imports.local.add("duckDbArray");
+    const [, base, length] = arrayMatch;
+    return {
+      builder: `duckDbArray(${columnName(column.name)}, ${JSON.stringify(base)}, ${Number(length)})`
+    };
+  }
+  const listMatch = /^(.*)\[\]$/.exec(upper);
+  if (listMatch) {
+    imports.local.add("duckDbList");
+    const [, base] = listMatch;
+    return {
+      builder: `duckDbList(${columnName(column.name)}, ${JSON.stringify(base)})`
+    };
+  }
   if (upper.startsWith("CHAR(") || upper === "CHAR") {
     imports.pgCore.add("char");
     const length = column.characterLength;
@@ -1267,22 +1457,6 @@ function mapDuckDbType(column, imports, options) {
     imports.local.add("duckDbBlob");
     return { builder: `duckDbBlob(${columnName(column.name)})` };
   }
-  const arrayMatch = /^(.*)\[(\d+)\]$/.exec(upper);
-  if (arrayMatch) {
-    imports.local.add("duckDbArray");
-    const [, base, length] = arrayMatch;
-    return {
-      builder: `duckDbArray(${columnName(column.name)}, ${JSON.stringify(base)}, ${Number(length)})`
-    };
-  }
-  const listMatch = /^(.*)\[\]$/.exec(upper);
-  if (listMatch) {
-    imports.local.add("duckDbList");
-    const [, base] = listMatch;
-    return {
-      builder: `duckDbList(${columnName(column.name)}, ${JSON.stringify(base)})`
-    };
-  }
   if (upper.startsWith("STRUCT")) {
     imports.local.add("duckDbStruct");
     const inner = upper.replace(/^STRUCT\s*\(/i, "").replace(/\)$/, "");
@@ -1531,7 +1705,7 @@ async function main() {
     throw new Error("Missing required --url");
   }
   const instanceOptions = options.url.startsWith("md:") && process.env.MOTHERDUCK_TOKEN ? { motherduck_token: process.env.MOTHERDUCK_TOKEN } : undefined;
-  const instance = await DuckDBInstance.create(options.url, instanceOptions);
+  const instance = await DuckDBInstance3.create(options.url, instanceOptions);
   const connection = await instance.connect();
   const db = drizzle(connection);
   try {

package/dist/helpers.d.ts

@@ -0,0 +1 @@
+export { duckDbList, duckDbArray, duckDbMap, duckDbStruct, duckDbJson, duckDbBlob, duckDbInet, duckDbInterval, duckDbTimestamp, duckDbDate, duckDbTime, duckDbArrayContains, duckDbArrayContained, duckDbArrayOverlaps, } from './columns.ts';