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

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-core.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

@@ -1,3 +1,4 @@
+import { DuckDBInstance } from '@duckdb/node-api';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { DefaultLogger } from 'drizzle-orm/logger';
@@ -12,6 +13,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 +23,14 @@ 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';
+import { isPool } from './client.ts';
+import {
+  createDuckDBConnectionPool,
+  resolvePoolSize,
+  type DuckDBPoolConfig,
+  type PoolPreset,
+} from './pool.ts';
 
 export interface PgDriverOptions {
   logger?: Logger;
@@ -48,18 +58,57 @@ export class DuckDBDriver {
   }
 }
 
+/** 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>
+  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 function drizzle<
-  TSchema extends Record<string, unknown> = Record<string, never>
+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;
+}
+
+/** Check if a value looks like a config object (not a client) */
+function isConfigObject(data: unknown): data is Record<string, unknown> {
+  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
+  );
+}
+
+/** Internal: create database from a client (connection or pool) */
+function createFromClient<
+  TSchema extends Record<string, unknown> = Record<string, never>,
 >(
   client: DuckDBClientLike,
-  config: DuckDBDrizzleConfig<TSchema> = {}
+  config: DuckDBDrizzleConfig<TSchema> = {},
+  instance?: DuckDBInstance
 ): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>> {
   const dialect = new DuckDBDialect();
 
@@ -87,35 +136,173 @@ export function drizzle<
   });
   const session = driver.createSession(schema);
 
-  return new DuckDBDatabase(dialect, session, schema) as DuckDBDatabase<
-    TSchema,
-    ExtractTablesWithRelations<TSchema>
-  >;
+  const db = new DuckDBDatabase(dialect, session, schema, client, instance);
+  return db as DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
+}
+
+/** Internal: create database from a connection string */
+async function createFromConnectionString<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  path: string,
+  instanceOptions: Record<string, string> | undefined,
+  config: DuckDBDrizzleConfig<TSchema> = {}
+): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>> {
+  const instance = await DuckDBInstance.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);
+}
+
+// Overload 1: Connection string (async, auto-pools)
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  connectionString: string
+): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+
+// Overload 2: Connection string + config (async, auto-pools)
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  connectionString: string,
+  config: DuckDBDrizzleConfig<TSchema>
+): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+
+// Overload 3: Config with connection (async, auto-pools)
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  config: DuckDBDrizzleConfigWithConnection<TSchema>
+): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+
+// Overload 4: Config with explicit client (sync)
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  config: DuckDBDrizzleConfigWithClient<TSchema>
+): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
+
+// Overload 5: Explicit client (sync, backward compatible)
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  client: DuckDBClientLike,
+  config?: DuckDBDrizzleConfig<TSchema>
+): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
+
+// Implementation
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  clientOrConfigOrPath:
+    | string
+    | DuckDBClientLike
+    | DuckDBDrizzleConfigWithConnection<TSchema>
+    | DuckDBDrizzleConfigWithClient<TSchema>,
+  config?: DuckDBDrizzleConfig<TSchema>
+):
+  | DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>
+  | Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>> {
+  // String path -> async with auto-pool
+  if (typeof clientOrConfigOrPath === 'string') {
+    return createFromConnectionString(clientOrConfigOrPath, undefined, config);
+  }
+
+  // Config object with connection or client
+  if (isConfigObject(clientOrConfigOrPath)) {
+    const configObj = clientOrConfigOrPath as
+      | DuckDBDrizzleConfigWithConnection<TSchema>
+      | DuckDBDrizzleConfigWithClient<TSchema>;
+
+    if ('connection' in configObj) {
+      const connConfig =
+        configObj as DuckDBDrizzleConfigWithConnection<TSchema>;
+      const { connection, ...restConfig } = connConfig;
+      if (typeof connection === 'string') {
+        return createFromConnectionString(
+          connection,
+          undefined,
+          restConfig as DuckDBDrizzleConfig<TSchema>
+        );
+      }
+      return createFromConnectionString(
+        connection.path,
+        connection.options,
+        restConfig as DuckDBDrizzleConfig<TSchema>
+      );
+    }
+
+    if ('client' in configObj) {
+      const clientConfig = configObj as DuckDBDrizzleConfigWithClient<TSchema>;
+      const { client: clientValue, ...restConfig } = clientConfig;
+      return createFromClient(
+        clientValue,
+        restConfig as DuckDBDrizzleConfig<TSchema>
+      );
+    }
+
+    throw new Error(
+      'Invalid drizzle config: either connection or client must be provided'
+    );
+  }
+
+  // Direct client (backward compatible)
+  return createFromClient(clientOrConfigOrPath as DuckDBClientLike, config);
 }
 
 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';
 
+  /** The underlying connection or pool */
+  readonly $client: DuckDBClientLike;
+
+  /** The DuckDB instance (when created from connection string) */
+  readonly $instance?: DuckDBInstance;
+
   constructor(
     readonly dialect: DuckDBDialect,
     readonly session: DuckDBSession<TFullSchema, TSchema>,
-    schema: RelationalSchemaConfig<TSchema> | undefined
+    schema: RelationalSchemaConfig<TSchema> | undefined,
+    client: DuckDBClientLike,
+    instance?: DuckDBInstance
   ) {
     super(dialect, session, schema);
+    this.$client = client;
+    this.$instance = instance;
+  }
+
+  /**
+   * Close the database connection pool and instance.
+   * Should be called when shutting down the application.
+   */
+  async close(): Promise<void> {
+    if (isPool(this.$client) && this.$client.close) {
+      await this.$client.close();
+    }
+    // Note: DuckDBInstance doesn't have a close method in the current API
   }
 
   select(): DuckDBSelectBuilder<undefined>;
   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;
 
+    // Cast needed: DuckDBSession is compatible but types don't align exactly with PgSession
     return new DuckDBSelectBuilder({
       fields: selectedFields ?? undefined,
       session: this.session as unknown as PgSession<DuckDBQueryResultHKT>,
@@ -123,6 +310,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/helpers.ts

@@ -0,0 +1,18 @@
+// Client-safe entrypoint exposing schema builder utilities without pulling
+// the DuckDB Node API bindings. Intended for generated schemas and browser use.
+export {
+  duckDbList,
+  duckDbArray,
+  duckDbMap,
+  duckDbStruct,
+  duckDbJson,
+  duckDbBlob,
+  duckDbInet,
+  duckDbInterval,
+  duckDbTimestamp,
+  duckDbDate,
+  duckDbTime,
+  duckDbArrayContains,
+  duckDbArrayContained,
+  duckDbArrayOverlaps,
+} from './columns.ts';

package/src/index.ts

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

package/src/introspect.ts

@@ -108,7 +108,8 @@ type ImportBuckets = {
   local: Set<string>;
 };
 
-const DEFAULT_IMPORT_BASE = '@leonardovida-md/drizzle-neo-duckdb';
+export const DEFAULT_IMPORT_BASE =
+  '@leonardovida-md/drizzle-neo-duckdb/helpers';
 
 export async function introspect(
   db: DuckDBDatabase,
@@ -466,17 +467,17 @@ function emitConstraints(
           .map((col) => `t.${toIdentifier(col)}`)
           .join(', ')}], name: ${JSON.stringify(constraint.name)} })`
       );
-    } else if (
-      constraint.type === 'UNIQUE' &&
-      constraint.columns.length > 1
-    ) {
+    } else if (constraint.type === 'UNIQUE' && constraint.columns.length > 1) {
       imports.pgCore.add('unique');
       entries.push(
         `${key}: unique(${JSON.stringify(constraint.name)}).on(${constraint.columns
           .map((col) => `t.${toIdentifier(col)}`)
           .join(', ')})`
       );
-    } else if (constraint.type === 'FOREIGN KEY' && constraint.referencedTable) {
+    } else if (
+      constraint.type === 'FOREIGN KEY' &&
+      constraint.referencedTable
+    ) {
       imports.pgCore.add('foreignKey');
       const targetTable = toIdentifier(constraint.referencedTable.name);
       entries.push(
@@ -546,7 +547,10 @@ function buildDefault(defaultValue: string | null): string {
   if (/^nextval\(/i.test(trimmed)) {
     return `.default(sql\`${trimmed}\`)`;
   }
-  if (/^current_timestamp(?:\(\))?$/i.test(trimmed) || /^now\(\)$/i.test(trimmed)) {
+  if (
+    /^current_timestamp(?:\(\))?$/i.test(trimmed) ||
+    /^now\(\)$/i.test(trimmed)
+  ) {
     return `.defaultNow()`;
   }
   if (trimmed === 'true' || trimmed === 'false') {
@@ -604,7 +608,11 @@ function mapDuckDbType(
 
   if (upper === 'BIGINT' || upper === 'INT8' || upper === 'UBIGINT') {
     imports.pgCore.add('bigint');
-    return { builder: `bigint(${columnName(column.name)})` };
+    // Drizzle's bigint helper requires an explicit mode. Default to 'number'
+    // to mirror DuckDB's typical 64-bit integer behavior in JS.
+    return {
+      builder: `bigint(${columnName(column.name)}, { mode: 'number' })`,
+    };
   }
 
   const decimalMatch = /^DECIMAL\((\d+),(\d+)\)/i.exec(upper);
@@ -642,6 +650,28 @@ function mapDuckDbType(
     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;
@@ -692,28 +722,6 @@ function mapDuckDbType(
     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(/\)$/, '');
@@ -894,9 +902,7 @@ function renderImports(imports: ImportBuckets, importBasePath: string): string {
   const pgCore = [...imports.pgCore];
   if (pgCore.length) {
     lines.push(
-      `import { ${pgCore
-        .sort()
-        .join(', ')} } from 'drizzle-orm/pg-core';`
+      `import { ${pgCore.sort().join(', ')} } from 'drizzle-orm/pg-core';`
     );
   }
 

package/src/migrator.ts

@@ -10,15 +10,13 @@ export async function migrate<TSchema extends Record<string, unknown>>(
   config: DuckDbMigrationConfig
 ) {
   const migrationConfig: MigrationConfig =
-    typeof config === 'string'
-      ? { migrationsFolder: config }
-      : config;
+    typeof config === 'string' ? { migrationsFolder: config } : config;
 
   const migrations = readMigrationFiles(migrationConfig);
 
+  // Cast needed: Drizzle's internal PgSession type differs from exported type
   await db.dialect.migrate(
     migrations,
-    // Need to work around omitted internal types from drizzle...
     db.session as unknown as PgSession,
     migrationConfig
   );