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

package/dist/introspect.d.ts

@@ -63,4 +63,12 @@ export interface IntrospectResult {
 }
 export declare const DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb/helpers";
 export declare function introspect(db: DuckDBDatabase, opts?: IntrospectOptions): Promise<IntrospectResult>;
+export declare function buildDefault(defaultValue: string | null): string;
+export declare function parseStructFields(inner: string): Array<{
+    name: string;
+    type: string;
+}>;
+export declare function parseMapValue(raw: string): string;
+export declare function splitTopLevel(input: string, delimiter: string): string[];
+export declare function toIdentifier(name: string): string;
 export {};

package/dist/pool.d.ts

@@ -16,6 +16,14 @@ export declare function resolvePoolSize(pool: DuckDBPoolConfig | PoolPreset | fa
 export interface DuckDBConnectionPoolOptions {
     /** Maximum concurrent connections. Defaults to 4. */
     size?: number;
+    /** Timeout in milliseconds to wait for a connection. Defaults to 30000 (30s). */
+    acquireTimeout?: number;
+    /** Maximum number of requests waiting for a connection. Defaults to 100. */
+    maxWaitingRequests?: number;
+    /** Max time (ms) a connection may live before being recycled. */
+    maxLifetimeMs?: number;
+    /** Max idle time (ms) before an idle connection is discarded. */
+    idleTimeoutMs?: number;
 }
 export declare function createDuckDBConnectionPool(instance: DuckDBInstance, options?: DuckDBConnectionPoolOptions): DuckDBConnectionPool & {
     size: number;

package/dist/session.d.ts

@@ -44,12 +44,17 @@ export declare class DuckDBSession<TFullSchema extends Record<string, unknown> =
     private rewriteArrays;
     private rejectStringArrayLiterals;
     private hasWarnedArrayLiteral;
+    private rollbackOnly;
     constructor(client: DuckDBClientLike, dialect: DuckDBDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: DuckDBSessionOptions);
     prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][]) => T['execute']): PgPreparedQuery<T>;
-    transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
     private warnOnStringArrayLiteral;
     executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
     executeArrow(query: SQL): Promise<unknown>;
+    markRollbackOnly(): void;
+    isRollbackOnly(): boolean;
 }
 export declare class DuckDBTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     static readonly [entityKind]: string;
@@ -59,6 +64,7 @@ export declare class DuckDBTransaction<TFullSchema extends Record<string, unknow
     executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
     executeArrow(query: SQL): Promise<unknown>;
     transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+    private runNestedWithoutSavepoint;
 }
 export type GenericRowData<T extends RowData = RowData> = T;
 export type GenericTableData<T = RowData> = T[];

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

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

package/dist/sql/result-mapper.d.ts

@@ -1,2 +1,9 @@
 import { type AnyColumn, type SelectedFieldsOrdered } from 'drizzle-orm';
+export declare function normalizeInet(value: unknown): unknown;
+export declare function normalizeTimestampString(value: unknown, withTimezone: boolean): string | unknown;
+export declare function normalizeTimestamp(value: unknown, withTimezone: boolean): Date | unknown;
+export declare function normalizeDateString(value: unknown): string | unknown;
+export declare function normalizeDateValue(value: unknown): Date | unknown;
+export declare function normalizeTime(value: unknown): string | unknown;
+export declare function normalizeInterval(value: unknown): string | unknown;
 export declare function mapResultRow<TResult>(columns: SelectedFieldsOrdered<AnyColumn>, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): TResult;

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

@@ -23,7 +23,7 @@ export interface StructValueWrapper extends DuckDBValueWrapper<'struct', Record<
 export interface MapValueWrapper extends DuckDBValueWrapper<'map', Record<string, unknown>> {
     readonly valueType?: string;
 }
-export interface TimestampValueWrapper extends DuckDBValueWrapper<'timestamp', Date | string> {
+export interface TimestampValueWrapper extends DuckDBValueWrapper<'timestamp', Date | string | number | bigint> {
     readonly withTimezone: boolean;
     readonly precision?: number;
 }
@@ -37,6 +37,6 @@ export declare function wrapList(data: unknown[], elementType?: string): ListVal
 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 wrapTimestamp(data: Date | string | number | bigint, withTimezone: boolean, precision?: number): TimestampValueWrapper;
 export declare function wrapBlob(data: Buffer | Uint8Array): BlobValueWrapper;
 export declare function wrapJson(data: unknown): JsonValueWrapper;

package/package.json

@@ -3,7 +3,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {

package/src/bin/duckdb-introspect.ts

@@ -12,6 +12,7 @@ interface CliOptions {
   allDatabases: boolean;
   schemas?: string[];
   outFile: string;
+  outMeta?: string;
   includeViews: boolean;
   useCustomTimeTypes: boolean;
   importBasePath?: string;
@@ -20,6 +21,7 @@ interface CliOptions {
 function parseArgs(argv: string[]): CliOptions {
   const options: CliOptions = {
     outFile: path.resolve(process.cwd(), 'drizzle/schema.ts'),
+    outMeta: undefined,
     allDatabases: false,
     includeViews: false,
     useCustomTimeTypes: true,
@@ -52,6 +54,14 @@ function parseArgs(argv: string[]): CliOptions {
           argv[++i] ?? 'drizzle/schema.ts'
         );
         break;
+      case '--out-json':
+      case '--outJson':
+      case '--json':
+        options.outMeta = path.resolve(
+          process.cwd(),
+          argv[++i] ?? 'drizzle/schema.meta.json'
+        );
+        break;
       case '--include-views':
       case '--includeViews':
         options.includeViews = true;
@@ -88,6 +98,7 @@ Options:
   --all-databases  Introspect all attached databases (not just current)
   --schema         Comma separated schema list (defaults to all non-system schemas)
   --out            Output file (default: ./drizzle/schema.ts)
+  --json           Optional JSON metadata output (default: ./drizzle/schema.meta.json)
   --include-views  Include views in the generated schema
   --use-pg-time    Use pg-core timestamp/date/time instead of DuckDB custom helpers
   --import-base    Override import path for duckdb helpers (default: package name)
@@ -136,8 +147,19 @@ async function main() {
 
     await mkdir(path.dirname(options.outFile), { recursive: true });
     await writeFile(options.outFile, result.files.schemaTs, 'utf8');
+    if (options.outMeta) {
+      await mkdir(path.dirname(options.outMeta), { recursive: true });
+      await writeFile(
+        options.outMeta,
+        JSON.stringify(result.files.metaJson, null, 2),
+        'utf8'
+      );
+    }
 
     console.log(`Wrote schema to ${options.outFile}`);
+    if (options.outMeta) {
+      console.log(`Wrote metadata to ${options.outMeta}`);
+    }
   } finally {
     if (
       'closeSync' in connection &&
@@ -145,6 +167,11 @@ async function main() {
     ) {
       connection.closeSync();
     }
+    if ('closeSync' in instance && typeof instance.closeSync === 'function') {
+      instance.closeSync();
+    } else if ('close' in instance && typeof instance.close === 'function') {
+      await instance.close();
+    }
   }
 }
 

package/src/client.ts

@@ -49,17 +49,20 @@ export function prepareParams(
   options: PrepareParamsOptions = {}
 ): unknown[] {
   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 (typeof param === 'string') {
+      const trimmed = param.trim();
+      if (trimmed && isPgArrayLiteral(trimmed)) {
+        if (options.rejectStringArrayLiterals) {
+          throw new Error(
+            'Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.'
+          );
+        }
+
+        if (options.warnOnStringArrayLiteral) {
+          options.warnOnStringArrayLiteral();
+        }
+        return parsePgArrayLiteral(trimmed);
       }
-
-      if (options.warnOnStringArrayLiteral) {
-        options.warnOnStringArrayLiteral();
-      }
-      return parsePgArrayLiteral(param);
     }
     return param;
   });

package/src/columns.ts

@@ -63,7 +63,7 @@ type StructColType = `STRUCT (${string})`;
 
 type Primitive = AnyColType | ListColType | ArrayColType | StructColType;
 
-function coerceArrayString(value: string): unknown[] | undefined {
+export function coerceArrayString(value: string): unknown[] | undefined {
   const trimmed = value.trim();
   if (!trimmed) {
     return [];
@@ -86,7 +86,7 @@ function coerceArrayString(value: string): unknown[] | undefined {
   return undefined;
 }
 
-function formatLiteral(value: unknown, typeHint?: string): string {
+export function formatLiteral(value: unknown, typeHint?: string): string {
   if (value === null || value === undefined) {
     return 'NULL';
   }
@@ -123,7 +123,7 @@ function formatLiteral(value: unknown, typeHint?: string): string {
   return `'${escaped}'`;
 }
 
-function buildListLiteral(values: unknown[], elementType?: string): SQL {
+export function buildListLiteral(values: unknown[], elementType?: string): SQL {
   if (values.length === 0) {
     return sql`[]`;
   }
@@ -135,7 +135,7 @@ function buildListLiteral(values: unknown[], elementType?: string): SQL {
   return sql`list_value(${sql.join(chunks, sql.raw(', '))})`;
 }
 
-function buildStructLiteral(
+export function buildStructLiteral(
   value: Record<string, unknown>,
   schema?: Record<string, Primitive>
 ): SQL {
@@ -154,7 +154,7 @@ function buildStructLiteral(
   return sql`struct_pack(${sql.join(parts, sql.raw(', '))})`;
 }
 
-function buildMapLiteral(
+export function buildMapLiteral(
   value: Record<string, unknown>,
   valueType?: string
 ): SQL {
@@ -188,11 +188,11 @@ export const duckDbList = <TData = unknown>(
       }
       if (typeof value === 'string') {
         const parsed = coerceArrayString(value);
-        if (parsed) {
+        if (parsed !== undefined) {
           return parsed as TData[];
         }
       }
-      return [] as TData[];
+      return value as unknown as TData[];
     },
   })(name);
 
@@ -219,11 +219,11 @@ export const duckDbArray = <TData = unknown>(
       }
       if (typeof value === 'string') {
         const parsed = coerceArrayString(value);
-        if (parsed) {
+        if (parsed !== undefined) {
           return parsed as TData[];
         }
       }
-      return [] as TData[];
+      return value as unknown as TData[];
     },
   })(name);
 

package/src/dialect.ts

@@ -19,18 +19,64 @@ import {
   type QueryTypingsValue,
 } from 'drizzle-orm';
 
+const enum SavepointSupport {
+  Unknown = 0,
+  Yes = 1,
+  No = 2,
+}
+
 export class DuckDBDialect extends PgDialect {
   static readonly [entityKind]: string = 'DuckDBPgDialect';
+  // Track if PG JSON columns were detected during the current query preparation.
+  // Reset before each query via DuckDBSession to keep detection per-query.
   private hasPgJsonColumn = false;
+  // Track savepoint support per-dialect instance to avoid cross-contamination
+  // when multiple database connections with different capabilities exist.
+  private savepointsSupported: SavepointSupport = SavepointSupport.Unknown;
+
+  /**
+   * Reset the PG JSON detection flag. Should be called before preparing a new query.
+   */
+  resetPgJsonFlag(): void {
+    this.hasPgJsonColumn = false;
+  }
+
+  /**
+   * Mark that a PG JSON/JSONB column was detected during query preparation.
+   */
+  markPgJsonDetected(): void {
+    this.hasPgJsonColumn = true;
+  }
 
   assertNoPgJsonColumns(): void {
     if (this.hasPgJsonColumn) {
       throw new Error(
-        'Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB’s native JSON type.'
+        "Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type."
       );
     }
   }
 
+  /**
+   * Check if savepoints are known to be unsupported for this dialect instance.
+   */
+  areSavepointsUnsupported(): boolean {
+    return this.savepointsSupported === SavepointSupport.No;
+  }
+
+  /**
+   * Mark that savepoints are supported for this dialect instance.
+   */
+  markSavepointsSupported(): void {
+    this.savepointsSupported = SavepointSupport.Yes;
+  }
+
+  /**
+   * Mark that savepoints are not supported for this dialect instance.
+   */
+  markSavepointsUnsupported(): void {
+    this.savepointsSupported = SavepointSupport.No;
+  }
+
   override async migrate(
     migrations: MigrationMeta[],
     session: PgSession,
@@ -117,8 +163,10 @@ export class DuckDBDialect extends PgDialect {
     encoder: DriverValueEncoder<unknown, unknown>
   ): QueryTypingsValue {
     if (is(encoder, PgJsonb) || is(encoder, PgJson)) {
-      this.hasPgJsonColumn = true;
-      return 'none';
+      this.markPgJsonDetected();
+      throw new Error(
+        "Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type."
+      );
     } else if (is(encoder, PgNumeric)) {
       return 'decimal';
     } else if (is(encoder, PgTime)) {

package/src/driver.ts

@@ -24,7 +24,7 @@ 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 { closeClientConnection, isPool } from './client.ts';
 import {
   createDuckDBConnectionPool,
   resolvePoolSize,
@@ -290,7 +290,20 @@ export class DuckDBDatabase<
     if (isPool(this.$client) && this.$client.close) {
       await this.$client.close();
     }
-    // Note: DuckDBInstance doesn't have a close method in the current API
+    if (!isPool(this.$client)) {
+      await closeClientConnection(this.$client);
+    }
+    if (this.$instance) {
+      const maybeClosable = this.$instance as unknown as {
+        close?: () => Promise<void> | void;
+        closeSync?: () => void;
+      };
+      if (typeof maybeClosable.close === 'function') {
+        await maybeClosable.close();
+      } else if (typeof maybeClosable.closeSync === 'function') {
+        maybeClosable.closeSync();
+      }
+    }
   }
 
   select(): DuckDBSelectBuilder<undefined>;

package/src/introspect.ts

@@ -535,7 +535,7 @@ function emitColumn(
   return builder;
 }
 
-function buildDefault(defaultValue: string | null): string {
+export function buildDefault(defaultValue: string | null): string {
   if (!defaultValue) {
     return '';
   }
@@ -707,6 +707,22 @@ function mapDuckDbType(
     return { builder: `text(${columnName(column.name)}) /* JSON */` };
   }
 
+  if (upper.startsWith('ENUM')) {
+    imports.pgCore.add('text');
+    const enumLiteral = raw.replace(/^ENUM\s*/i, '').trim();
+    return {
+      builder: `text(${columnName(column.name)}) /* ENUM ${enumLiteral} */`,
+    };
+  }
+
+  if (upper.startsWith('UNION')) {
+    imports.pgCore.add('text');
+    const unionLiteral = raw.replace(/^UNION\s*/i, '').trim();
+    return {
+      builder: `text(${columnName(column.name)}) /* UNION ${unionLiteral} */`,
+    };
+  }
+
   if (upper === 'INET') {
     imports.local.add('duckDbInet');
     return { builder: `duckDbInet(${columnName(column.name)})` };
@@ -788,15 +804,16 @@ function mapDuckDbType(
   }
 
   // Fallback: keep as text to avoid runtime failures.
+  // Unknown types are mapped to text with a comment indicating the original type.
   imports.pgCore.add('text');
   return {
     builder: `text(${columnName(
       column.name
-    )}) /* TODO: verify type ${upper} */`,
+    )}) /* unsupported DuckDB type: ${upper} */`,
   };
 }
 
-function parseStructFields(
+export function parseStructFields(
   inner: string
 ): Array<{ name: string; type: string }> {
   const result: Array<{ name: string; type: string }> = [];
@@ -813,7 +830,7 @@ function parseStructFields(
   return result;
 }
 
-function parseMapValue(raw: string): string {
+export function parseMapValue(raw: string): string {
   const inner = raw.replace(/^MAP\(/i, '').replace(/\)$/, '');
   const parts = splitTopLevel(inner, ',');
   if (parts.length < 2) {
@@ -822,7 +839,7 @@ function parseMapValue(raw: string): string {
   return parts[1]?.trim() ?? 'TEXT';
 }
 
-function splitTopLevel(input: string, delimiter: string): string[] {
+export function splitTopLevel(input: string, delimiter: string): string[] {
   const parts: string[] = [];
   let depth = 0;
   let current = '';
@@ -847,7 +864,7 @@ function tableKey(schema: string, table: string): string {
   return `${schema}.${table}`;
 }
 
-function toIdentifier(name: string): string {
+export function toIdentifier(name: string): string {
   const cleaned = name.replace(/[^A-Za-z0-9_]/g, '_');
   const parts = cleaned.split('_').filter(Boolean);
   const base = parts