@duckdbfan/drizzle-duckdb 0.0.6 → 1.3.1

package/dist/driver.d.ts

@@ -1,59 +1,75 @@
+import { DuckDBInstance } from '@duckdb/node-api';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { PgDatabase } from 'drizzle-orm/pg-core/db';
-import { PgDialect } from 'drizzle-orm/pg-core/dialect';
+import type { SelectedFields } from 'drizzle-orm/pg-core/query-builders';
 import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from 'drizzle-orm/relations';
-import { type DrizzleConfig, type DrizzleTypeError } from 'drizzle-orm/utils';
-import type { DuckDBClient, DuckDBQueryResultHKT, DuckDBTransaction } from './session';
+import { type DrizzleConfig } from 'drizzle-orm/utils';
+import type { SQL } from 'drizzle-orm/sql/sql';
+import type { DuckDBClientLike, DuckDBQueryResultHKT, DuckDBTransaction } from './session.ts';
 import { DuckDBSession } from './session.ts';
 import { DuckDBDialect } from './dialect.ts';
-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 { SQL, type ColumnsSelection } from 'drizzle-orm/sql/sql';
-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 { DuckDBSelectBuilder } from './select-builder.ts';
+import type { ExecuteBatchesRawChunk, ExecuteInBatchesOptions, RowData } from './client.ts';
+import { type DuckDBPoolConfig, type PoolPreset } from './pool.ts';
+import { type PreparedStatementCacheConfig, type PrepareCacheOption } from './options.ts';
 export interface PgDriverOptions {
     logger?: Logger;
+    rejectStringArrayLiterals?: boolean;
+    prepareCache?: PreparedStatementCacheConfig;
 }
 export declare class DuckDBDriver {
     private client;
     private dialect;
     private options;
     static readonly [entityKind]: string;
-    constructor(client: DuckDBClient, dialect: DuckDBDialect, options?: PgDriverOptions);
+    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, options?: PgDriverOptions);
     createSession(schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined): DuckDBSession<Record<string, unknown>, TablesRelationalConfig>;
 }
-export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: DuckDBClient, config?: DrizzleConfig<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
+/** 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>> extends DrizzleConfig<TSchema> {
+    rejectStringArrayLiterals?: boolean;
+    prepareCache?: PrepareCacheOption;
+    /** Pool configuration. Use preset name, size config, or false to disable. */
+    pool?: DuckDBPoolConfig | PoolPreset | false;
+}
+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;
+}
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(connectionString: string): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(connectionString: string, config: DuckDBDrizzleConfig<TSchema>): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DuckDBDrizzleConfigWithConnection<TSchema>): Promise<DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DuckDBDrizzleConfigWithClient<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: DuckDBClientLike, config?: DuckDBDrizzleConfig<TSchema>): DuckDBDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
 export declare class DuckDBDatabase<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends PgDatabase<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     readonly dialect: DuckDBDialect;
     readonly session: DuckDBSession<TFullSchema, TSchema>;
     static readonly [entityKind]: string;
-    constructor(dialect: DuckDBDialect, session: DuckDBSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined);
-    select(): PgSelectBuilder<undefined>;
-    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    /** The underlying connection or pool */
+    readonly $client: DuckDBClientLike;
+    /** The DuckDB instance (when created from connection string) */
+    readonly $instance?: DuckDBInstance;
+    constructor(dialect: DuckDBDialect, session: DuckDBSession<TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined, client: DuckDBClientLike, instance?: DuckDBInstance);
+    /**
+     * Close the database connection pool and instance.
+     * Should be called when shutting down the application.
+     */
+    close(): Promise<void>;
+    select(): DuckDBSelectBuilder<undefined>;
+    select<TSelection extends SelectedFields>(fields: TSelection): DuckDBSelectBuilder<TSelection>;
+    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<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>;
 }
-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: PgDialect;
-        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 {};