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

package/dist/value-wrappers.d.ts

@@ -0,0 +1,104 @@
+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;
+/**
+ * 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;

package/package.json

@@ -3,14 +3,17 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
     "test": "vitest",
-    "t": "vitest --watch --ui"
+    "t": "vitest --watch --ui",
+    "bench": "vitest bench --runInBand test/perf",
+    "perf:run": "bun run scripts/run-perf.ts",
+    "perf:compare": "bun run scripts/compare-perf.ts"
   },
   "bin": {
     "duckdb-introspect": "dist/duckdb-introspect.mjs"
@@ -33,7 +36,8 @@
     "prettier": "^3.5.3",
     "typescript": "^5.8.2",
     "uuid": "^10.0.0",
-    "vitest": "^1.6.0"
+    "vitest": "^1.6.0",
+    "tinybench": "^2.7.1"
   },
   "repository": {
     "type": "git",

package/src/bin/duckdb-introspect.ts

@@ -40,11 +40,17 @@ function parseArgs(argv: string[]): CliOptions {
         break;
       case '--schema':
       case '--schemas':
-        options.schemas = argv[++i]?.split(',').map((s) => s.trim()).filter(Boolean);
+        options.schemas = argv[++i]
+          ?.split(',')
+          .map((s) => s.trim())
+          .filter(Boolean);
         break;
       case '--out':
       case '--outFile':
-        options.outFile = path.resolve(process.cwd(), argv[++i] ?? 'drizzle/schema.ts');
+        options.outFile = path.resolve(
+          process.cwd(),
+          argv[++i] ?? 'drizzle/schema.ts'
+        );
         break;
       case '--include-views':
       case '--includeViews':
@@ -133,7 +139,10 @@ async function main() {
 
     console.log(`Wrote schema to ${options.outFile}`);
   } finally {
-    if ('closeSync' in connection && typeof connection.closeSync === 'function') {
+    if (
+      'closeSync' in connection &&
+      typeof connection.closeSync === 'function'
+    ) {
       connection.closeSync();
     }
   }

package/src/client.ts

@@ -1,8 +1,14 @@
 import {
   listValue,
+  timestampValue,
   type DuckDBConnection,
   type DuckDBValue,
 } from '@duckdb/node-api';
+import {
+  DUCKDB_VALUE_MARKER,
+  wrapperToNodeApiValue,
+  type AnyDuckDBValueWrapper,
+} from './value-wrappers.ts';
 
 export type DuckDBClientLike = DuckDBConnection;
 export type RowData = Record<string, unknown>;
@@ -50,13 +56,62 @@ export function prepareParams(
   });
 }
 
+/**
+ * Convert a value to DuckDB Node API value.
+ * Handles wrapper types and plain values for backward compatibility.
+ * Optimized for the common case (primitives) in the hot path.
+ */
 function toNodeApiValue(value: unknown): DuckDBValue {
+  // Fast path 1: null/undefined
+  if (value == null) return null;
+
+  // Fast path 2: primitives (most common)
+  const t = typeof value;
+  if (t === 'string' || t === 'number' || t === 'bigint' || t === 'boolean') {
+    return value as DuckDBValue;
+  }
+
+  // Fast path 3: pre-wrapped DuckDB value (Symbol check ~2-3ns)
+  if (t === 'object' && DUCKDB_VALUE_MARKER in (value as object)) {
+    return wrapperToNodeApiValue(
+      value as AnyDuckDBValueWrapper,
+      toNodeApiValue
+    );
+  }
+
+  // Legacy path: plain arrays (backward compatibility)
   if (Array.isArray(value)) {
     return listValue(value.map((inner) => toNodeApiValue(inner)));
   }
+
+  // Date conversion to timestamp
+  if (value instanceof Date) {
+    return timestampValue(BigInt(value.getTime()) * 1000n);
+  }
+
+  // Fallback for unknown objects
   return value as DuckDBValue;
 }
 
+function deduplicateColumns(columns: string[]): string[] {
+  const seen: Record<string, number> = {};
+  return columns.map((col) => {
+    const count = seen[col] ?? 0;
+    seen[col] = count + 1;
+    return count === 0 ? col : `${col}_${count}`;
+  });
+}
+
+function mapRowsToObjects(columns: string[], rows: unknown[][]): RowData[] {
+  return rows.map((vals) => {
+    const obj: Record<string, unknown> = {};
+    columns.forEach((col, idx) => {
+      obj[col] = vals[idx];
+    });
+    return obj;
+  }) as RowData[];
+}
+
 export async function closeClientConnection(
   connection: DuckDBConnection
 ): Promise<void> {
@@ -65,10 +120,7 @@ export async function closeClientConnection(
     return;
   }
 
-  if (
-    'closeSync' in connection &&
-    typeof connection.closeSync === 'function'
-  ) {
+  if ('closeSync' in connection && typeof connection.closeSync === 'function') {
     connection.closeSync();
     return;
   }
@@ -92,19 +144,84 @@ export async function executeOnClient(
       : undefined;
   const result = await client.run(query, values);
   const rows = await result.getRowsJS();
-  const columns = result.columnNames();
-  const seen: Record<string, number> = {};
-  const uniqueColumns = columns.map((col) => {
-    const count = seen[col] ?? 0;
-    seen[col] = count + 1;
-    return count === 0 ? col : `${col}_${count}`;
-  });
+  const columns =
+    // prefer deduplicated names when available (Node API >=1.4.2)
+    result.deduplicatedColumnNames?.() ?? result.columnNames();
+  const uniqueColumns = deduplicateColumns(columns);
 
-  return (rows ?? []).map((vals) => {
-    const obj: Record<string, unknown> = {};
-    uniqueColumns.forEach((col, idx) => {
-      obj[col] = vals[idx];
-    });
-    return obj;
-  }) as RowData[];
+  return rows ? mapRowsToObjects(uniqueColumns, rows) : [];
+}
+
+export interface ExecuteInBatchesOptions {
+  rowsPerChunk?: number;
+}
+
+/**
+ * Stream results from DuckDB in batches to avoid fully materializing rows in JS.
+ */
+export async function* executeInBatches(
+  client: DuckDBClientLike,
+  query: string,
+  params: unknown[],
+  options: ExecuteInBatchesOptions = {}
+): AsyncGenerator<RowData[], void, void> {
+  const rowsPerChunk =
+    options.rowsPerChunk && options.rowsPerChunk > 0
+      ? options.rowsPerChunk
+      : 100_000;
+  const values =
+    params.length > 0
+      ? (params.map((param) => toNodeApiValue(param)) as DuckDBValue[])
+      : undefined;
+
+  const result = await client.stream(query, values);
+  const columns =
+    // prefer deduplicated names when available (Node API >=1.4.2)
+    result.deduplicatedColumnNames?.() ?? result.columnNames();
+  const uniqueColumns = deduplicateColumns(columns);
+
+  let buffer: RowData[] = [];
+
+  for await (const chunk of result.yieldRowsJs()) {
+    const objects = mapRowsToObjects(uniqueColumns, chunk);
+    for (const row of objects) {
+      buffer.push(row);
+      if (buffer.length >= rowsPerChunk) {
+        yield buffer;
+        buffer = [];
+      }
+    }
+  }
+
+  if (buffer.length > 0) {
+    yield buffer;
+  }
+}
+
+/**
+ * Return columnar results when the underlying node-api exposes an Arrow/columnar API.
+ * Falls back to column-major JS arrays when Arrow is unavailable.
+ */
+export async function executeArrowOnClient(
+  client: DuckDBClientLike,
+  query: string,
+  params: unknown[]
+): Promise<unknown> {
+  const values =
+    params.length > 0
+      ? (params.map((param) => toNodeApiValue(param)) as DuckDBValue[])
+      : undefined;
+  const result = await client.run(query, values);
+
+  const maybeArrow =
+    (result as unknown as { toArrow?: () => Promise<unknown> }).toArrow ??
+    (result as unknown as { getArrowTable?: () => Promise<unknown> })
+      .getArrowTable;
+
+  if (typeof maybeArrow === 'function') {
+    return await maybeArrow.call(result);
+  }
+
+  // Fallback: return column-major JS arrays to avoid per-row object creation.
+  return result.getColumnsObjectJS();
 }

package/src/columns.ts

@@ -1,6 +1,18 @@
 import { sql, type SQL } from 'drizzle-orm';
 import type { SQLWrapper } from 'drizzle-orm/sql/sql';
 import { customType } from 'drizzle-orm/pg-core';
+import {
+  wrapList,
+  wrapArray,
+  wrapMap,
+  wrapBlob,
+  wrapJson,
+  type ListValueWrapper,
+  type ArrayValueWrapper,
+  type MapValueWrapper,
+  type BlobValueWrapper,
+  type JsonValueWrapper,
+} from './value-wrappers.ts';
 
 type IntColType =
   | 'SMALLINT'
@@ -93,7 +105,9 @@ function formatLiteral(value: unknown, typeHint?: string): string {
   }
 
   const str =
-    typeof value === 'string' ? value : JSON.stringify(value) ?? String(value);
+    typeof value === 'string'
+      ? value
+      : (JSON.stringify(value) ?? String(value));
 
   const escaped = str.replace(/'/g, "''");
   // Simple quoting based on hint.
@@ -140,7 +154,10 @@ function buildStructLiteral(
   return sql`struct_pack(${sql.join(parts, sql.raw(', '))})`;
 }
 
-function buildMapLiteral(value: Record<string, unknown>, valueType?: string): SQL {
+function buildMapLiteral(
+  value: Record<string, unknown>,
+  valueType?: string
+): SQL {
   const keys = Object.keys(value);
   const vals = Object.values(value);
   const keyList = buildListLiteral(keys, 'TEXT');
@@ -155,14 +172,17 @@ export const duckDbList = <TData = unknown>(
   name: string,
   elementType: AnyColType
 ) =>
-  customType<{ data: TData[]; driverData: SQL | unknown[] | string }>({
+  customType<{
+    data: TData[];
+    driverData: ListValueWrapper | unknown[] | string;
+  }>({
     dataType() {
       return `${elementType}[]`;
     },
-    toDriver(value: TData[]) {
-      return buildListLiteral(value, elementType);
+    toDriver(value: TData[]): ListValueWrapper {
+      return wrapList(value, elementType);
     },
-    fromDriver(value: unknown[] | string | SQL): TData[] {
+    fromDriver(value: unknown[] | string | ListValueWrapper): TData[] {
       if (Array.isArray(value)) {
         return value as TData[];
       }
@@ -181,16 +201,19 @@ export const duckDbArray = <TData = unknown>(
   elementType: AnyColType,
   fixedLength?: number
 ) =>
-  customType<{ data: TData[]; driverData: SQL | unknown[] | string }>({
+  customType<{
+    data: TData[];
+    driverData: ArrayValueWrapper | unknown[] | string;
+  }>({
     dataType() {
       return fixedLength
         ? `${elementType}[${fixedLength}]`
         : `${elementType}[]`;
     },
-    toDriver(value: TData[]) {
-      return buildListLiteral(value, elementType);
+    toDriver(value: TData[]): ArrayValueWrapper {
+      return wrapArray(value, elementType, fixedLength);
     },
-    fromDriver(value: unknown[] | string | SQL): TData[] {
+    fromDriver(value: unknown[] | string | ArrayValueWrapper): TData[] {
       if (Array.isArray(value)) {
         return value as TData[];
       }
@@ -208,15 +231,15 @@ export const duckDbMap = <TData extends Record<string, any>>(
   name: string,
   valueType: AnyColType | ListColType | ArrayColType
 ) =>
-  customType<{ data: TData; driverData: TData }>({
-  dataType() {
+  customType<{ data: TData; driverData: MapValueWrapper | TData }>({
+    dataType() {
       return `MAP (STRING, ${valueType})`;
     },
-    toDriver(value: TData) {
-      return buildMapLiteral(value, valueType);
+    toDriver(value: TData): MapValueWrapper {
+      return wrapMap(value, valueType);
     },
-    fromDriver(value: TData): TData {
-      return value;
+    fromDriver(value: TData | MapValueWrapper): TData {
+      return value as TData;
     },
   })(name);
 
@@ -233,6 +256,8 @@ export const duckDbStruct = <TData extends Record<string, any>>(
       return `STRUCT (${fields.join(', ')})`;
     },
     toDriver(value: TData) {
+      // Use SQL literals for structs due to DuckDB type inference issues
+      // with nested empty lists
       return buildStructLiteral(value, schema);
     },
     fromDriver(value: TData | string): TData {
@@ -247,15 +272,24 @@ export const duckDbStruct = <TData extends Record<string, any>>(
     },
   })(name);
 
+/**
+ * JSON column type that wraps values and delays JSON.stringify() to binding time.
+ * This ensures consistent handling with other wrapped types.
+ *
+ * Note: DuckDB stores JSON as VARCHAR internally, so the final binding
+ * is always a stringified JSON value.
+ */
 export const duckDbJson = <TData = unknown>(name: string) =>
-  customType<{ data: TData; driverData: SQL | string }>({
+  customType<{ data: TData; driverData: JsonValueWrapper | SQL | string }>({
     dataType() {
       return 'JSON';
     },
-    toDriver(value: TData) {
+    toDriver(value: TData): JsonValueWrapper | SQL | string {
+      // Pass through strings directly
       if (typeof value === 'string') {
         return value;
       }
+      // Pass through SQL objects (for raw SQL expressions)
       if (
         value !== null &&
         typeof value === 'object' &&
@@ -263,9 +297,10 @@ export const duckDbJson = <TData = unknown>(name: string) =>
       ) {
         return value as unknown as SQL;
       }
-      return JSON.stringify(value ?? null);
+      // Wrap non-string values for delayed stringify at binding time
+      return wrapJson(value);
     },
-    fromDriver(value: SQL | string) {
+    fromDriver(value: SQL | string | JsonValueWrapper) {
       if (typeof value !== 'string') {
         return value as unknown as TData;
       }
@@ -283,14 +318,14 @@ export const duckDbJson = <TData = unknown>(name: string) =>
 
 export const duckDbBlob = customType<{
   data: Buffer;
+  driverData: BlobValueWrapper;
   default: false;
 }>({
   dataType() {
     return 'BLOB';
   },
-  toDriver(value: Buffer) {
-    const hexString = value.toString('hex');
-    return sql`from_hex(${hexString})`;
+  toDriver(value: Buffer): BlobValueWrapper {
+    return wrapBlob(value);
   },
 });
 
@@ -322,10 +357,7 @@ interface TimestampOptions {
   precision?: number;
 }
 
-export const duckDbTimestamp = (
-  name: string,
-  options: TimestampOptions = {}
-) =>
+export const duckDbTimestamp = (name: string, options: TimestampOptions = {}) =>
   customType<{
     data: Date | string;
     driverData: SQL | string | Date;
@@ -338,6 +370,7 @@ export const duckDbTimestamp = (
       return `TIMESTAMP${precision}`;
     },
     toDriver(value: Date | string) {
+      // Use SQL literals for timestamps due to Bun/DuckDB bigint binding issues
       const iso = value instanceof Date ? value.toISOString() : value;
       const normalized = iso.replace('T', ' ').replace('Z', '+00');
       const typeKeyword = options.withTimezone ? 'TIMESTAMPTZ' : 'TIMESTAMP';
@@ -353,11 +386,9 @@ export const duckDbTimestamp = (
       if (value instanceof Date) {
         return value;
       }
-      const stringValue =
-        typeof value === 'string' ? value : value.toString();
+      const stringValue = typeof value === 'string' ? value : value.toString();
       const hasOffset =
-        stringValue.endsWith('Z') ||
-        /[+-]\d{2}:?\d{2}$/.test(stringValue);
+        stringValue.endsWith('Z') || /[+-]\d{2}:?\d{2}$/.test(stringValue);
       const normalized = hasOffset
         ? stringValue.replace(' ', 'T')
         : `${stringValue.replace(' ', 'T')}Z`;
@@ -374,11 +405,9 @@ export const duckDbDate = (name: string) =>
       return value;
     },
     fromDriver(value: string | Date) {
-        const str =
-          value instanceof Date
-            ? value.toISOString().slice(0, 10)
-            : value;
-        return str;
+      const str =
+        value instanceof Date ? value.toISOString().slice(0, 10) : value;
+      return str;
     },
   })(name);
 

package/src/dialect.ts

@@ -52,8 +52,8 @@ export class DuckDBDialect extends PgDialect {
 
     const migrationTableCreate = sql`
       CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(
-      migrationsTable
-    )} (
+        migrationsTable
+      )} (
         id integer PRIMARY KEY default nextval('${sql.raw(sequenceLiteral)}'),
         hash text NOT NULL,
         created_at bigint

package/src/driver.ts

@@ -12,6 +12,7 @@ import {
   type TablesRelationalConfig,
 } from 'drizzle-orm/relations';
 import { type DrizzleConfig } from 'drizzle-orm/utils';
+import type { SQL } from 'drizzle-orm/sql/sql';
 import type {
   DuckDBClientLike,
   DuckDBQueryResultHKT,
@@ -21,6 +22,7 @@ import { DuckDBSession } from './session.ts';
 import { DuckDBDialect } from './dialect.ts';
 import { DuckDBSelectBuilder } from './select-builder.ts';
 import { aliasFields } from './sql/selection.ts';
+import type { ExecuteInBatchesOptions, RowData } from './client.ts';
 
 export interface PgDriverOptions {
   logger?: Logger;
@@ -49,14 +51,14 @@ export class DuckDBDriver {
 }
 
 export interface DuckDBDrizzleConfig<
-  TSchema extends Record<string, unknown> = Record<string, never>
+  TSchema extends Record<string, unknown> = Record<string, never>,
 > extends DrizzleConfig<TSchema> {
   rewriteArrays?: boolean;
   rejectStringArrayLiterals?: boolean;
 }
 
 export function drizzle<
-  TSchema extends Record<string, unknown> = Record<string, never>
+  TSchema extends Record<string, unknown> = Record<string, never>,
 >(
   client: DuckDBClientLike,
   config: DuckDBDrizzleConfig<TSchema> = {}
@@ -95,7 +97,8 @@ export function drizzle<
 
 export class DuckDBDatabase<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
-  TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>
+  TSchema extends
+    TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
 > extends PgDatabase<DuckDBQueryResultHKT, TFullSchema, TSchema> {
   static readonly [entityKind]: string = 'DuckDBDatabase';
 
@@ -111,9 +114,9 @@ export class DuckDBDatabase<
   select<TSelection extends SelectedFields>(
     fields: TSelection
   ): DuckDBSelectBuilder<TSelection>;
-  select(fields?: SelectedFields): DuckDBSelectBuilder<
-    SelectedFields | undefined
-  > {
+  select(
+    fields?: SelectedFields
+  ): DuckDBSelectBuilder<SelectedFields | undefined> {
     const selectedFields = fields ? aliasFields(fields) : undefined;
 
     return new DuckDBSelectBuilder({
@@ -123,6 +126,17 @@ export class DuckDBDatabase<
     });
   }
 
+  executeBatches<T extends RowData = RowData>(
+    query: SQL,
+    options: ExecuteInBatchesOptions = {}
+  ): AsyncGenerator<T[], void, void> {
+    return this.session.executeBatches<T>(query, options);
+  }
+
+  executeArrow(query: SQL): Promise<unknown> {
+    return this.session.executeArrow(query);
+  }
+
   override async transaction<T>(
     transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>
   ): Promise<T> {

package/src/index.ts

@@ -3,3 +3,6 @@ export * from './session.ts';
 export * from './columns.ts';
 export * from './migrator.ts';
 export * from './introspect.ts';
+export * from './client.ts';
+export * from './olap.ts';
+export * from './value-wrappers.ts';