@duckdbfan/drizzle-duckdb 0.0.7 → 1.3.2

package/dist/introspect.d.ts

@@ -0,0 +1,74 @@
+import type { RowData } from './client.ts';
+import type { DuckDBDatabase } from './driver.ts';
+export interface IntrospectOptions {
+    /**
+     * Database/catalog to introspect. If not specified, uses the current database
+     * (via `SELECT current_database()`). This prevents returning tables from all
+     * attached databases in MotherDuck workspaces.
+     */
+    database?: string;
+    /**
+     * When true, introspects all attached databases instead of just the current one.
+     * Ignored if `database` is explicitly set.
+     * @default false
+     */
+    allDatabases?: boolean;
+    schemas?: string[];
+    includeViews?: boolean;
+    useCustomTimeTypes?: boolean;
+    mapJsonAsDuckDbJson?: boolean;
+    importBasePath?: string;
+}
+interface DuckDbIndexRow extends RowData {
+    schema_name: string;
+    table_name: string;
+    index_name: string;
+    is_unique: boolean | null;
+    expressions: string | null;
+}
+export interface IntrospectedColumn {
+    name: string;
+    dataType: string;
+    columnDefault: string | null;
+    nullable: boolean;
+    characterLength: number | null;
+    numericPrecision: number | null;
+    numericScale: number | null;
+}
+export interface IntrospectedConstraint {
+    name: string;
+    type: string;
+    columns: string[];
+    referencedTable?: {
+        name: string;
+        schema: string;
+        columns: string[];
+    };
+    rawExpression?: string | null;
+}
+export interface IntrospectedTable {
+    schema: string;
+    name: string;
+    kind: 'table' | 'view';
+    columns: IntrospectedColumn[];
+    constraints: IntrospectedConstraint[];
+    indexes: DuckDbIndexRow[];
+}
+export interface IntrospectResult {
+    files: {
+        schemaTs: string;
+        metaJson: IntrospectedTable[];
+        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 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/migrator.d.ts

@@ -1,3 +1,4 @@
 import type { MigrationConfig } from 'drizzle-orm/migrator';
-import type { DuckDBDatabase } from './driver';
-export declare function migrate<TSchema extends Record<string, unknown>>(db: DuckDBDatabase<TSchema>, config: MigrationConfig): Promise<void>;
+import type { DuckDBDatabase } from './driver.ts';
+export type DuckDbMigrationConfig = MigrationConfig | string;
+export declare function migrate<TSchema extends Record<string, unknown>>(db: DuckDBDatabase<TSchema>, config: DuckDbMigrationConfig): Promise<void>;

package/dist/olap.d.ts

@@ -0,0 +1,46 @@
+import { Subquery, type SQLWrapper } from 'drizzle-orm';
+import type { AnyPgColumn, PgTable } from 'drizzle-orm/pg-core';
+import type { PgViewBase } from 'drizzle-orm/pg-core/view-base';
+import { SQL } from 'drizzle-orm/sql/sql';
+import type { DuckDBDatabase } from './driver.ts';
+export declare const countN: (expr?: SQLWrapper) => SQL<number>;
+export declare const sumN: (expr: SQLWrapper) => SQL<number>;
+export declare const avgN: (expr: SQLWrapper) => SQL<number>;
+export declare const sumDistinctN: (expr: SQLWrapper) => SQL<number>;
+export declare const percentileCont: (p: number, expr: SQLWrapper) => SQL<number>;
+export declare const median: (expr: SQLWrapper) => SQL<number>;
+export declare const anyValue: <T = unknown>(expr: SQLWrapper) => SQL<T>;
+type PartitionOrder = {
+    partitionBy?: SQLWrapper | SQLWrapper[];
+    orderBy?: SQLWrapper | SQLWrapper[];
+} | undefined;
+export declare const rowNumber: (options?: PartitionOrder) => SQL<number>;
+export declare const rank: (options?: PartitionOrder) => SQL<number>;
+export declare const denseRank: (options?: PartitionOrder) => SQL<number>;
+export declare const lag: <T = unknown>(expr: SQLWrapper, offset?: number, defaultValue?: SQLWrapper, options?: PartitionOrder) => SQL<T>;
+export declare const lead: <T = unknown>(expr: SQLWrapper, offset?: number, defaultValue?: SQLWrapper, options?: PartitionOrder) => SQL<T>;
+type ValueExpr = SQL | SQL.Aliased | AnyPgColumn;
+type GroupKey = ValueExpr;
+type MeasureMap = Record<string, ValueExpr>;
+type NonAggMap = Record<string, ValueExpr>;
+export declare class OlapBuilder {
+    private db;
+    private source?;
+    private keys;
+    private measureMap;
+    private nonAggregates;
+    private wrapNonAggWithAnyValue;
+    private orderByClauses;
+    constructor(db: DuckDBDatabase);
+    from(source: PgTable | Subquery | PgViewBase | SQL): this;
+    groupBy(keys: GroupKey[]): this;
+    measures(measures: MeasureMap): this;
+    selectNonAggregates(fields: NonAggMap, options?: {
+        anyValue?: boolean;
+    }): this;
+    orderBy(...clauses: ValueExpr[]): this;
+    build(): any;
+    run(): any;
+}
+export declare const olap: (db: DuckDBDatabase) => OlapBuilder;
+export {};

package/dist/operators.d.ts

@@ -0,0 +1,8 @@
+/**
+ * DuckDB-native array operators. Generate DuckDB-compatible SQL directly
+ * without query rewriting.
+ */
+import { type SQL, type SQLWrapper } from 'drizzle-orm';
+export declare function arrayHasAll<T>(column: SQLWrapper, values: T[] | SQLWrapper): SQL;
+export declare function arrayHasAny<T>(column: SQLWrapper, values: T[] | SQLWrapper): SQL;
+export declare function arrayContainedBy<T>(column: SQLWrapper, values: T[] | SQLWrapper): SQL;

package/dist/options.d.ts

@@ -0,0 +1,7 @@
+export type PrepareCacheOption = boolean | number | {
+    size?: number;
+};
+export interface PreparedStatementCacheConfig {
+    size: number;
+}
+export declare function resolvePrepareCacheOption(option?: PrepareCacheOption): PreparedStatementCacheConfig | undefined;

package/dist/pool.d.ts

@@ -0,0 +1,30 @@
+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;
+    /** 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/select-builder.d.ts

@@ -0,0 +1,31 @@
+import { PgSelectBuilder, type CreatePgSelectFromBuilderMode, type SelectedFields, type TableLikeHasEmptySelection } from 'drizzle-orm/pg-core/query-builders';
+import { PgColumn, PgTable, type PgSession } from 'drizzle-orm/pg-core';
+import { Subquery, ViewBaseConfig, type SQLWrapper } from 'drizzle-orm';
+import { PgViewBase } from 'drizzle-orm/pg-core/view-base';
+import type { GetSelectTableName, GetSelectTableSelection } from 'drizzle-orm/query-builders/select.types';
+import { SQL, type ColumnsSelection } from 'drizzle-orm/sql/sql';
+import type { DuckDBDialect } from './dialect.ts';
+import { type DrizzleTypeError } from 'drizzle-orm/utils';
+interface PgViewBaseInternal<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
+    [ViewBaseConfig]?: {
+        selectedFields: SelectedFields;
+    };
+}
+export declare class DuckDBSelectBuilder<TSelection extends SelectedFields | undefined, TBuilderMode extends 'db' | 'qb' = 'db'> extends PgSelectBuilder<TSelection, TBuilderMode> {
+    private _fields;
+    private _session;
+    private _dialect;
+    private _withList;
+    private _distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: PgSession | undefined;
+        dialect: DuckDBDialect;
+        withList?: Subquery[];
+        distinct?: boolean | {
+            on: (PgColumn | SQLWrapper)[];
+        };
+    });
+    from<TFrom extends PgTable | Subquery | PgViewBaseInternal | SQL>(source: TableLikeHasEmptySelection<TFrom> extends true ? DrizzleTypeError<"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"> : TFrom): CreatePgSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
+}
+export {};

package/dist/session.d.ts

@@ -1,6 +1,5 @@
-import type { Connection, Database, RowData } from 'duckdb-async';
 import { entityKind } from 'drizzle-orm/entity';
-import { type Logger } from 'drizzle-orm/logger';
+import type { Logger } from 'drizzle-orm/logger';
 import { PgTransaction } from 'drizzle-orm/pg-core';
 import type { SelectedFieldsOrdered } from 'drizzle-orm/pg-core/query-builders/select.types';
 import type { PgTransactionConfig, PreparedQueryConfig, PgQueryResultHKT } from 'drizzle-orm/pg-core/session';
@@ -8,41 +7,67 @@ import { PgPreparedQuery, PgSession } from 'drizzle-orm/pg-core/session';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from 'drizzle-orm/relations';
 import { type Query, SQL } from 'drizzle-orm/sql/sql';
 import type { Assume } from 'drizzle-orm/utils';
-import type { DuckDBDialect } from './dialect';
-export type DuckDBClient = Database;
+import type { DuckDBDialect } from './dialect.ts';
+import type { DuckDBClientLike, RowData } from './client.ts';
+import { type ExecuteBatchesRawChunk, type ExecuteInBatchesOptions } from './client.ts';
+import type { PreparedStatementCacheConfig } from './options.ts';
+export type { DuckDBClientLike, RowData } from './client.ts';
 export declare class DuckDBPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
     private client;
+    private dialect;
     private queryString;
     private params;
     private logger;
     private fields;
     private _isResponseInArrayMode;
-    private customResultMapper?;
+    private customResultMapper;
+    private rejectStringArrayLiterals;
+    private prepareCache;
+    private warnOnStringArrayLiteral?;
     static readonly [entityKind]: string;
-    constructor(client: DuckDBClient | Connection, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper?: ((rows: unknown[][]) => T["execute"]) | undefined);
+    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined, rejectStringArrayLiterals: boolean, prepareCache: PreparedStatementCacheConfig | undefined, warnOnStringArrayLiteral?: ((sql: string) => void) | undefined);
     execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
     all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
     isResponseInArrayMode(): boolean;
 }
 export interface DuckDBSessionOptions {
     logger?: Logger;
+    rejectStringArrayLiterals?: boolean;
+    prepareCache?: PreparedStatementCacheConfig;
 }
 export declare class DuckDBSession<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgSession<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     private client;
     private schema;
     private options;
     static readonly [entityKind]: string;
+    protected dialect: DuckDBDialect;
     private logger;
-    constructor(client: DuckDBClient | Connection, dialect: DuckDBDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: DuckDBSessionOptions);
+    private rejectStringArrayLiterals;
+    private prepareCache;
+    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>;
+    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, 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;
     rollback(): never;
     getTransactionConfigSQL(config: PgTransactionConfig): SQL;
     setTransaction(config: PgTransactionConfig): Promise<void>;
+    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
+    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, 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/ast-transformer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AST-based SQL transformer for DuckDB compatibility.
+ *
+ * Transforms:
+ * - Array operators: @>, <@, && -> array_has_all(), array_has_any()
+ * - JOIN column qualification: "col" = "col" -> "left"."col" = "right"."col"
+ *
+ * Performance optimizations:
+ * - LRU cache for transformed queries (avoids re-parsing identical queries)
+ * - Smart heuristics to skip JOIN qualification when not needed
+ * - Early exit when no transformation is required
+ */
+export type TransformResult = {
+    sql: string;
+    transformed: boolean;
+};
+export declare function transformSQL(query: string): TransformResult;
+/**
+ * Clear the transformation cache. Useful for testing or memory management.
+ */
+export declare function clearTransformCache(): void;
+/**
+ * Get current cache statistics for monitoring.
+ */
+export declare function getTransformCacheStats(): {
+    size: number;
+    maxSize: number;
+};
+export declare function needsTransformation(query: string): boolean;
+export { transformArrayOperators } from './visitors/array-operators.ts';
+export { qualifyJoinColumns } from './visitors/column-qualifier.ts';
+export { rewriteGenerateSeriesAliases } from './visitors/generate-series-alias.ts';
+export { hoistUnionWith } from './visitors/union-with-hoister.ts';

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

@@ -0,0 +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/sql/selection.d.ts

@@ -0,0 +1,2 @@
+import type { SelectedFields } from 'drizzle-orm/pg-core';
+export declare function aliasFields(fields: SelectedFields, fullJoin?: boolean): SelectedFields;

package/dist/sql/visitors/array-operators.d.ts

@@ -0,0 +1,5 @@
+/**
+ * AST visitor to transform Postgres array operators to DuckDB functions.
+ */
+import type { AST } from 'node-sql-parser';
+export declare function transformArrayOperators(ast: AST | AST[]): boolean;

package/dist/sql/visitors/column-qualifier.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AST visitor to qualify unqualified column references in JOIN ON clauses.
+ *
+ * Performance optimizations:
+ * - Early exit when no unqualified columns found in ON clause
+ * - Skip processing if all columns are already qualified
+ * - Minimal tree traversal when possible
+ */
+import type { AST } from 'node-sql-parser';
+export declare function qualifyJoinColumns(ast: AST | AST[]): boolean;

package/dist/sql/visitors/generate-series-alias.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AST visitor to rewrite Postgres style generate_series aliases.
+ *
+ * Postgres lets you reference a generate_series alias as a column:
+ *   FROM generate_series(...) AS gs
+ *   SELECT gs::date
+ *
+ * DuckDB treats gs as a table alias, and the column is generate_series.
+ * This visitor rewrites unqualified column refs that match a
+ * generate_series alias to gs.generate_series.
+ */
+import type { AST } from 'node-sql-parser';
+export declare function rewriteGenerateSeriesAliases(ast: AST | AST[]): boolean;

package/dist/sql/visitors/union-with-hoister.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AST visitor to hoist WITH clauses out of UNION and other set operations.
+ *
+ * Drizzle can emit SQL like:
+ *   (with a as (...) select ...) union (with b as (...) select ...)
+ *
+ * DuckDB 1.4.x has an internal binder bug for this pattern.
+ * We merge per arm CTEs into a single top level WITH when names do not collide.
+ */
+import type { AST } from 'node-sql-parser';
+export declare function hoistUnionWith(ast: AST | AST[]): boolean;

package/dist/utils.d.ts

@@ -1,5 +1,2 @@
-import { type SelectedFieldsOrdered, type AnyColumn } from 'drizzle-orm';
-import { type SelectedFields } from 'drizzle-orm/pg-core';
-export declare function mapResultRow<TResult>(columns: SelectedFieldsOrdered<AnyColumn>, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): TResult;
-export declare function aliasFields(fields: SelectedFields, fullJoin?: boolean): SelectedFields;
-export declare function queryAdapter(query: string): string;
+export { aliasFields } from './sql/selection.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 | number | bigint> {
+    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 | number | bigint, 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

@@ -0,0 +1,8 @@
+import { type DuckDBValue } from '@duckdb/node-api';
+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

@@ -1,36 +1,70 @@
 {
   "name": "@duckdbfan/drizzle-duckdb",
-  "module": "index.ts",
-  "main": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "version": "0.0.7",
+  "module": "./dist/index.mjs",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "version": "1.3.2",
   "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 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"
+    "t": "vitest --watch --ui",
+    "bench": "vitest bench --run test/perf --pool=threads --poolOptions.threads.singleThread=true --no-file-parallelism",
+    "perf:run": "bun run scripts/run-perf.ts",
+    "perf:compare": "bun run scripts/compare-perf.ts",
+    "publish:dual": "bun run scripts/publish-dual.ts",
+    "publish:dual:dry": "bun run scripts/publish-dual.ts --dry-run"
+  },
+  "bin": {
+    "duckdb-introspect": "dist/duckdb-introspect.mjs"
   },
   "peerDependencies": {
-    "drizzle-orm": "^0.40.0",
-    "duckdb-async": "^1.0.0"
+    "@duckdb/node-api": "1.4.4-r.1",
+    "drizzle-orm": "^0.40.0"
+  },
+  "peerDependenciesMeta": {
+    "@duckdb/node-api": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@duckdb/node-api": "1.4.4-r.1",
     "@types/bun": "^1.2.5",
     "@types/uuid": "^10.0.0",
     "@vitest/ui": "^1.6.0",
     "drizzle-orm": "0.40.0",
-    "duckdb-async": "^1.2.0",
     "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",
-    "url": "git+https://github.com/duckdbfan/drizzle-duckdb.git"
+    "url": "git+https://github.com/leonardovida/drizzle-duckdb.git"
+  },
+  "exports": {
+    ".": {
+      "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,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "packageManager": "bun@1.3.6",
   "keywords": [
     "drizzle",
     "duckdb"
@@ -38,12 +72,15 @@
   "author": "M L",
   "license": "Apache-2.0",
   "bugs": {
-    "url": "https://github.com/duckdbfan/drizzle-duckdb/issues"
+    "url": "https://github.com/leonardovida/drizzle-duckdb/issues"
   },
-  "homepage": "https://github.com/duckdbfan/drizzle-duckdb#readme",
+  "homepage": "https://github.com/leonardovida/drizzle-duckdb#readme",
   "files": [
-    "src/*.ts",
+    "src/**/*.ts",
     "dist/*.mjs",
-    "dist/*.d.ts"
-  ]
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "node-sql-parser": "^5.3.13"
+  }
 }