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

package/dist/index.mjs

@@ -1,4 +1,5 @@
 // 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";
@@ -15,10 +16,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" },
@@ -35,6 +32,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;
       }
@@ -62,6 +61,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;
       }
@@ -317,6 +318,8 @@ import {
   timestampValue,
   timestampTZValue
 } from "@duckdb/node-api";
+
+// src/value-wrappers-core.ts
 var DUCKDB_VALUE_MARKER = Symbol.for("drizzle-duckdb:value");
 function isDuckDBWrapper(value) {
   return value !== null && typeof value === "object" && DUCKDB_VALUE_MARKER in value && value[DUCKDB_VALUE_MARKER] === true;
@@ -377,6 +380,8 @@ function wrapJson(data) {
     data
   };
 }
+
+// src/value-wrappers.ts
 function dateToMicros(value) {
   if (value instanceof Date) {
     return BigInt(value.getTime()) * 1000n;
@@ -434,6 +439,9 @@ function wrapperToNodeApiValue(wrapper, toValue) {
 }
 
 // src/client.ts
+function isPool(client) {
+  return typeof client.acquire === "function";
+}
 function isPgArrayLiteral(value) {
   return value.startsWith("{") && value.endsWith("}");
 }
@@ -445,15 +453,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);
@@ -510,6 +516,14 @@ async function closeClientConnection(connection) {
   }
 }
 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();
@@ -518,6 +532,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);
@@ -539,6 +562,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;
@@ -627,16 +658,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) => {
@@ -884,6 +929,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;
@@ -903,7 +1014,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;
@@ -921,17 +1039,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;
@@ -1220,7 +1381,7 @@ async function migrate(db, config) {
 // src/introspect.ts
 import { sql as sql5 } 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);
@@ -1556,6 +1717,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;
@@ -1596,22 +1773,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(/\)$/, "");
@@ -1891,6 +2052,7 @@ export {
   sumN,
   sumDistinctN,
   rowNumber,
+  resolvePoolSize,
   rank,
   prepareParams,
   percentileCont,
@@ -1899,6 +2061,7 @@ export {
   median,
   lead,
   lag,
+  isPool,
   isDuckDBWrapper,
   introspect,
   executeOnClient,
@@ -1920,15 +2083,18 @@ export {
   duckDbArray,
   drizzle,
   denseRank,
+  createDuckDBConnectionPool,
   countN,
   closeClientConnection,
   avgN,
   anyValue,
+  POOL_PRESETS,
   OlapBuilder,
   DuckDBTransaction,
   DuckDBSession,
   DuckDBPreparedQuery,
   DuckDBDriver,
   DuckDBDatabase,
-  DUCKDB_VALUE_MARKER
+  DUCKDB_VALUE_MARKER,
+  DEFAULT_IMPORT_BASE
 };

package/dist/introspect.d.ts

@@ -61,5 +61,6 @@ export interface IntrospectResult {
         relationsTs?: string;
     };
 }
+export declare const DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb/helpers";
 export declare function introspect(db: DuckDBDatabase, opts?: IntrospectOptions): Promise<IntrospectResult>;
 export {};

package/dist/pool.d.ts

@@ -0,0 +1,22 @@
+import { DuckDBInstance } from '@duckdb/node-api';
+import { type DuckDBConnectionPool } from './client.ts';
+/** Pool size presets for different MotherDuck instance types */
+export type PoolPreset = 'pulse' | 'standard' | 'jumbo' | 'mega' | 'giga' | 'local' | 'memory';
+/** Pool sizes optimized for each MotherDuck instance type */
+export declare const POOL_PRESETS: Record<PoolPreset, number>;
+export interface DuckDBPoolConfig {
+    /** Maximum concurrent connections. Defaults to 4. */
+    size?: number;
+}
+/**
+ * Resolve pool configuration to a concrete size.
+ * Returns false if pooling is disabled.
+ */
+export declare function resolvePoolSize(pool: DuckDBPoolConfig | PoolPreset | false | undefined): number | false;
+export interface DuckDBConnectionPoolOptions {
+    /** Maximum concurrent connections. Defaults to 4. */
+    size?: number;
+}
+export declare function createDuckDBConnectionPool(instance: DuckDBInstance, options?: DuckDBConnectionPoolOptions): DuckDBConnectionPool & {
+    size: number;
+};

package/dist/sql/query-rewriters.d.ts

@@ -1,2 +1 @@
 export declare function adaptArrayOperators(query: string): string;
-export declare function queryAdapter(query: string): string;

package/dist/utils.d.ts

@@ -1,3 +1,3 @@
 export { aliasFields } from './sql/selection.ts';
-export { adaptArrayOperators, queryAdapter } from './sql/query-rewriters.ts';
+export { adaptArrayOperators } from './sql/query-rewriters.ts';
 export { mapResultRow } from './sql/result-mapper.ts';

package/dist/value-wrappers-core.d.ts

@@ -0,0 +1,42 @@
+/**
+ * DuckDB wrapper value helpers that are safe for client-side bundles.
+ * These utilities only tag values; conversion to native bindings lives
+ * in value-wrappers.ts to avoid pulling @duckdb/node-api into browsers.
+ */
+export declare const DUCKDB_VALUE_MARKER: unique symbol;
+export type DuckDBValueKind = 'list' | 'array' | 'struct' | 'map' | 'timestamp' | 'blob' | 'json';
+export interface DuckDBValueWrapper<TKind extends DuckDBValueKind = DuckDBValueKind, TData = unknown> {
+    readonly [DUCKDB_VALUE_MARKER]: true;
+    readonly kind: TKind;
+    readonly data: TData;
+}
+export interface ListValueWrapper extends DuckDBValueWrapper<'list', unknown[]> {
+    readonly elementType?: string;
+}
+export interface ArrayValueWrapper extends DuckDBValueWrapper<'array', unknown[]> {
+    readonly elementType?: string;
+    readonly fixedLength?: number;
+}
+export interface StructValueWrapper extends DuckDBValueWrapper<'struct', Record<string, unknown>> {
+    readonly schema?: Record<string, string>;
+}
+export interface MapValueWrapper extends DuckDBValueWrapper<'map', Record<string, unknown>> {
+    readonly valueType?: string;
+}
+export interface TimestampValueWrapper extends DuckDBValueWrapper<'timestamp', Date | string> {
+    readonly withTimezone: boolean;
+    readonly precision?: number;
+}
+export interface BlobValueWrapper extends DuckDBValueWrapper<'blob', Buffer | Uint8Array> {
+}
+export interface JsonValueWrapper extends DuckDBValueWrapper<'json', unknown> {
+}
+export type AnyDuckDBValueWrapper = ListValueWrapper | ArrayValueWrapper | StructValueWrapper | MapValueWrapper | TimestampValueWrapper | BlobValueWrapper | JsonValueWrapper;
+export declare function isDuckDBWrapper(value: unknown): value is AnyDuckDBValueWrapper;
+export declare function wrapList(data: unknown[], elementType?: string): ListValueWrapper;
+export declare function wrapArray(data: unknown[], elementType?: string, fixedLength?: number): ArrayValueWrapper;
+export declare function wrapStruct(data: Record<string, unknown>, schema?: Record<string, string>): StructValueWrapper;
+export declare function wrapMap(data: Record<string, unknown>, valueType?: string): MapValueWrapper;
+export declare function wrapTimestamp(data: Date | string, withTimezone: boolean, precision?: number): TimestampValueWrapper;
+export declare function wrapBlob(data: Buffer | Uint8Array): BlobValueWrapper;
+export declare function wrapJson(data: unknown): JsonValueWrapper;

package/dist/value-wrappers.d.ts

@@ -1,104 +1,8 @@
 import { type DuckDBValue } from '@duckdb/node-api';
-/**
- * Symbol used to identify wrapped DuckDB values for native binding.
- * Uses Symbol.for() to ensure cross-module compatibility.
- */
-export declare const DUCKDB_VALUE_MARKER: unique symbol;
-/**
- * Type identifier for each wrapper kind.
- */
-export type DuckDBValueKind = 'list' | 'array' | 'struct' | 'map' | 'timestamp' | 'blob' | 'json';
-/**
- * Base interface for all tagged DuckDB value wrappers.
- */
-export interface DuckDBValueWrapper<TKind extends DuckDBValueKind = DuckDBValueKind, TData = unknown> {
-    readonly [DUCKDB_VALUE_MARKER]: true;
-    readonly kind: TKind;
-    readonly data: TData;
-}
-/**
- * List wrapper - maps to DuckDBListValue
- */
-export interface ListValueWrapper extends DuckDBValueWrapper<'list', unknown[]> {
-    readonly elementType?: string;
-}
-/**
- * Array wrapper (fixed size) - maps to DuckDBArrayValue
- */
-export interface ArrayValueWrapper extends DuckDBValueWrapper<'array', unknown[]> {
-    readonly elementType?: string;
-    readonly fixedLength?: number;
-}
-/**
- * Struct wrapper - maps to DuckDBStructValue
- */
-export interface StructValueWrapper extends DuckDBValueWrapper<'struct', Record<string, unknown>> {
-    readonly schema?: Record<string, string>;
-}
-/**
- * Map wrapper - maps to DuckDBMapValue
- */
-export interface MapValueWrapper extends DuckDBValueWrapper<'map', Record<string, unknown>> {
-    readonly valueType?: string;
-}
-/**
- * Timestamp wrapper - maps to DuckDBTimestampValue or DuckDBTimestampTZValue
- */
-export interface TimestampValueWrapper extends DuckDBValueWrapper<'timestamp', Date | string> {
-    readonly withTimezone: boolean;
-    readonly precision?: number;
-}
-/**
- * Blob wrapper - maps to DuckDBBlobValue
- */
-export interface BlobValueWrapper extends DuckDBValueWrapper<'blob', Buffer | Uint8Array> {
-}
-/**
- * JSON wrapper - delays JSON.stringify() to binding time.
- * DuckDB stores JSON as VARCHAR internally.
- */
-export interface JsonValueWrapper extends DuckDBValueWrapper<'json', unknown> {
-}
-/**
- * Union of all wrapper types for exhaustive type checking.
- */
-export type AnyDuckDBValueWrapper = ListValueWrapper | ArrayValueWrapper | StructValueWrapper | MapValueWrapper | TimestampValueWrapper | BlobValueWrapper | JsonValueWrapper;
-/**
- * Type guard to check if a value is a tagged DuckDB wrapper.
- * Optimized for fast detection in the hot path.
- */
-export declare function isDuckDBWrapper(value: unknown): value is AnyDuckDBValueWrapper;
-/**
- * Create a list wrapper for variable-length lists.
- */
-export declare function wrapList(data: unknown[], elementType?: string): ListValueWrapper;
-/**
- * Create an array wrapper for fixed-length arrays.
- */
-export declare function wrapArray(data: unknown[], elementType?: string, fixedLength?: number): ArrayValueWrapper;
-/**
- * Create a struct wrapper for named field structures.
- */
-export declare function wrapStruct(data: Record<string, unknown>, schema?: Record<string, string>): StructValueWrapper;
-/**
- * Create a map wrapper for key-value maps.
- */
-export declare function wrapMap(data: Record<string, unknown>, valueType?: string): MapValueWrapper;
-/**
- * Create a timestamp wrapper.
- */
-export declare function wrapTimestamp(data: Date | string, withTimezone: boolean, precision?: number): TimestampValueWrapper;
-/**
- * Create a blob wrapper for binary data.
- */
-export declare function wrapBlob(data: Buffer | Uint8Array): BlobValueWrapper;
-/**
- * Create a JSON wrapper that delays JSON.stringify() to binding time.
- * This ensures consistent handling with other wrapped types.
- */
-export declare function wrapJson(data: unknown): JsonValueWrapper;
+import { type AnyDuckDBValueWrapper } from './value-wrappers-core.ts';
 /**
  * Convert a wrapper to a DuckDB Node API value.
  * Uses exhaustive switch for compile-time safety.
  */
 export declare function wrapperToNodeApiValue(wrapper: AnyDuckDBValueWrapper, toValue: (v: unknown) => DuckDBValue): DuckDBValue;
+export { DUCKDB_VALUE_MARKER, isDuckDBWrapper, wrapArray, wrapBlob, wrapJson, wrapList, wrapMap, wrapStruct, wrapTimestamp, type AnyDuckDBValueWrapper, type DuckDBValueWrapper, type ArrayValueWrapper, type BlobValueWrapper, type JsonValueWrapper, type ListValueWrapper, type MapValueWrapper, type StructValueWrapper, type TimestampValueWrapper, type DuckDBValueKind, } from './value-wrappers-core.ts';

package/package.json

@@ -3,11 +3,11 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {
-    "build": "bun build --target=node ./src/index.ts --outfile=./dist/index.mjs --packages=external && bun build --target=node ./src/bin/duckdb-introspect.ts --outfile=./dist/duckdb-introspect.mjs --packages=external && bun run build:declarations",
+    "build": "bun build --target=node ./src/index.ts --outfile=./dist/index.mjs --packages=external && bun build --target=node ./src/helpers.ts --outfile=./dist/helpers.mjs --packages=external && bun build --target=node ./src/bin/duckdb-introspect.ts --outfile=./dist/duckdb-introspect.mjs --packages=external && bun run build:declarations",
     "build:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
     "test": "vitest",
     "t": "vitest --watch --ui",
@@ -48,6 +48,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
+    "./helpers": {
+      "types": "./dist/helpers.d.ts",
+      "import": "./dist/helpers.mjs"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,