@duckdbfan/drizzle-duckdb 0.0.1 → 0.0.3

package/dist/columns.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dialect.d.ts

@@ -0,0 +1,9 @@
+import { entityKind } from 'drizzle-orm/entity';
+import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
+import { PgDialect, PgSession } from 'drizzle-orm/pg-core';
+import { type DriverValueEncoder, type QueryTypingsValue } from 'drizzle-orm';
+export declare class DuckDBDialect extends PgDialect {
+    static readonly [entityKind]: string;
+    migrate(migrations: MigrationMeta[], session: PgSession, config: MigrationConfig): Promise<void>;
+    prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue;
+}

package/dist/driver.d.ts

@@ -0,0 +1,59 @@
+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 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 { 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';
+export interface PgDriverOptions {
+    logger?: Logger;
+}
+export declare class DuckDBDriver {
+    private client;
+    private dialect;
+    private options;
+    static readonly [entityKind]: string;
+    constructor(client: DuckDBClient, 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>>;
+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>;
+    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 {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './driver.ts';
+export * from './session.ts';
+export * from './columns.ts';