Initial commit

node_modules/drizzle-orm/sqlite-core/session.d.ts

@@ -0,0 +1,93 @@
+import { entityKind } from "../entity.js";
+import type { TablesRelationalConfig } from "../relations.js";
+import type { PreparedQuery } from "../session.js";
+import type { Query, SQL } from "../sql/sql.js";
+import type { SQLiteAsyncDialect, SQLiteSyncDialect } from "./dialect.js";
+import { QueryPromise } from "../query-promise.js";
+import { BaseSQLiteDatabase } from "./db.js";
+import type { SQLiteRaw } from "./query-builders/raw.js";
+import type { SelectedFieldsOrdered } from "./query-builders/select.types.js";
+export interface PreparedQueryConfig {
+    type: 'sync' | 'async';
+    run: unknown;
+    all: unknown;
+    get: unknown;
+    values: unknown;
+    execute: unknown;
+}
+export declare class ExecuteResultSync<T> extends QueryPromise<T> {
+    private resultCb;
+    static readonly [entityKind]: string;
+    constructor(resultCb: () => T);
+    execute(): Promise<T>;
+    sync(): T;
+}
+export type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult> : ExecuteResultSync<TResult>;
+export declare abstract class SQLitePreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
+    private mode;
+    private executeMethod;
+    protected query: Query;
+    static readonly [entityKind]: string;
+    constructor(mode: 'sync' | 'async', executeMethod: SQLiteExecuteMethod, query: Query);
+    getQuery(): Query;
+    abstract run(placeholderValues?: Record<string, unknown>): Result<T['type'], T['run']>;
+    mapRunResult(result: unknown, _isFromBatch?: boolean): unknown;
+    abstract all(placeholderValues?: Record<string, unknown>): Result<T['type'], T['all']>;
+    mapAllResult(_result: unknown, _isFromBatch?: boolean): unknown;
+    abstract get(placeholderValues?: Record<string, unknown>): Result<T['type'], T['get']>;
+    mapGetResult(_result: unknown, _isFromBatch?: boolean): unknown;
+    abstract values(placeholderValues?: Record<string, unknown>): Result<T['type'], T['values']>;
+    execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']>;
+    mapResult(response: unknown, isFromBatch?: boolean): unknown;
+}
+export interface SQLiteTransactionConfig {
+    behavior?: 'deferred' | 'immediate' | 'exclusive';
+}
+export type SQLiteExecuteMethod = 'run' | 'all' | 'get';
+export declare abstract class SQLiteSession<TResultKind extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> {
+    static readonly [entityKind]: string;
+    constructor(
+    /** @internal */
+    dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultKind]);
+    abstract prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown): SQLitePreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+    }>;
+    prepareOneTimeQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, isResponseInArrayMode: boolean): SQLitePreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+    }>;
+    abstract transaction<T>(transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>, config?: SQLiteTransactionConfig): Result<TResultKind, T>;
+    run(query: SQL): Result<TResultKind, TRunResult>;
+    all<T = unknown>(query: SQL): Result<TResultKind, T[]>;
+    get<T = unknown>(query: SQL): Result<TResultKind, T>;
+    values<T extends any[] = unknown[]>(query: SQL): Result<TResultKind, T[]>;
+    count(sql: SQL): Promise<number>;
+}
+export type Result<TKind extends 'sync' | 'async', TResult> = {
+    sync: TResult;
+    async: Promise<TResult>;
+}[TKind];
+export type DBResult<TKind extends 'sync' | 'async', TResult> = {
+    sync: TResult;
+    async: SQLiteRaw<TResult>;
+}[TKind];
+export declare abstract class SQLiteTransaction<TResultType extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends BaseSQLiteDatabase<TResultType, TRunResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(resultType: TResultType, dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultType], session: SQLiteSession<TResultType, TRunResult, TFullSchema, TSchema>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+}