kysely 0.28.17 → 0.29.0

package/dist/esm/dialect/sqlite/sqlite-introspector.d.ts

@@ -1,20 +0,0 @@
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
-import type { Kysely } from '../../kysely.js';
-export declare class SqliteIntrospector implements DatabaseIntrospector {
-    #private;
-    constructor(db: Kysely<any>);
-    /**
-     * Get schema metadata.
-     */
-    getSchemas(): Promise<SchemaMetadata[]>;
-    /**
-     * Get tables and views metadata.
-     */
-    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
-}

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -1,91 +0,0 @@
-/// <reference types="./sqlite-introspector.d.ts" />
-import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
-import { sql } from '../../raw-builder/sql.js';
-export class SqliteIntrospector {
-    #db;
-    constructor(db) {
-        this.#db = db;
-    }
-    async getSchemas() {
-        // Sqlite doesn't support schemas.
-        return [];
-    }
-    async getTables(options = { withInternalKyselyTables: false }) {
-        return await this.#getTableMetadata(options);
-    }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
-    #tablesQuery(qb, options) {
-        let tablesQuery = qb
-            .selectFrom('sqlite_master')
-            .where('type', 'in', ['table', 'view'])
-            .where('name', 'not like', 'sqlite_%')
-            .select(['name', 'sql', 'type'])
-            .orderBy('name');
-        if (!options.withInternalKyselyTables) {
-            tablesQuery = tablesQuery
-                .where('name', '!=', DEFAULT_MIGRATION_TABLE)
-                .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
-        }
-        return tablesQuery;
-    }
-    async #getTableMetadata(options) {
-        const tablesResult = await this.#tablesQuery(this.#db, options).execute();
-        const tableMetadata = await this.#db
-            .with('table_list', (qb) => this.#tablesQuery(qb, options))
-            .selectFrom([
-            'table_list as tl',
-            sql `pragma_table_info(tl.name)`.as('p'),
-        ])
-            .select([
-            'tl.name as table',
-            'p.cid',
-            'p.name',
-            'p.type',
-            'p.notnull',
-            'p.dflt_value',
-            'p.pk',
-        ])
-            .orderBy('tl.name')
-            .orderBy('p.cid')
-            .execute();
-        const columnsByTable = {};
-        for (const row of tableMetadata) {
-            columnsByTable[row.table] ??= [];
-            columnsByTable[row.table].push(row);
-        }
-        return tablesResult.map(({ name, sql, type }) => {
-            // // Try to find the name of the column that has `autoincrement` 🤦
-            let autoIncrementCol = sql
-                ?.split(/[\(\),]/)
-                ?.find((it) => it.toLowerCase().includes('autoincrement'))
-                ?.trimStart()
-                ?.split(/\s+/)?.[0]
-                ?.replace(/["`]/g, '');
-            const columns = columnsByTable[name] ?? [];
-            // Otherwise, check for an INTEGER PRIMARY KEY
-            // https://www.sqlite.org/autoinc.html
-            if (!autoIncrementCol) {
-                const pkCols = columns.filter((r) => r.pk > 0);
-                if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === 'integer') {
-                    autoIncrementCol = pkCols[0].name;
-                }
-            }
-            return {
-                name: name,
-                isView: type === 'view',
-                columns: columns.map((col) => ({
-                    name: col.name,
-                    dataType: col.type,
-                    isNullable: !col.notnull,
-                    isAutoIncrementing: col.name === autoIncrementCol,
-                    hasDefaultValue: col.dflt_value != null,
-                    comment: undefined,
-                })),
-            };
-        });
-    }
-}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -1,15 +0,0 @@
-import type { DefaultInsertValueNode } from '../../operation-node/default-insert-value-node.js';
-import type { OrActionNode } from '../../operation-node/or-action-node.js';
-import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
-export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
-    protected visitOrAction(node: OrActionNode): void;
-    protected getCurrentParameterPlaceholder(): string;
-    protected getLeftExplainOptionsWrapper(): string;
-    protected getRightExplainOptionsWrapper(): string;
-    protected getLeftIdentifierWrapper(): string;
-    protected getRightIdentifierWrapper(): string;
-    protected getAutoIncrement(): string;
-    protected sanitizeIdentifier(identifier: string): string;
-    protected sanitizeJSONPathMemberValue(value: string): string;
-    protected visitDefaultInsertValue(_: DefaultInsertValueNode): void;
-}

package/dist/esm/driver/connection-provider.d.ts

@@ -1,8 +0,0 @@
-import type { DatabaseConnection } from './database-connection.js';
-export interface ConnectionProvider {
-    /**
-     * Provides a connection for the callback and takes care of disposing
-     * the connection after the callback has been run.
-     */
-    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
-}

package/dist/esm/driver/database-connection.d.ts

@@ -1,35 +0,0 @@
-import type { CompiledQuery } from '../query-compiler/compiled-query.js';
-/**
- * A single connection to the database engine.
- *
- * These are created by an instance of {@link Driver}.
- */
-export interface DatabaseConnection {
-    executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
-    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
-}
-export interface QueryResult<O> {
-    /**
-     * This is defined for insert, update, delete and merge queries and contains
-     * the number of rows the query inserted/updated/deleted.
-     */
-    readonly numAffectedRows?: bigint;
-    /**
-     * This is defined for update queries and contains the number of rows
-     * the query changed.
-     *
-     * This is **optional** and only provided in dialects such as MySQL.
-     * You would probably use {@link numAffectedRows} in most cases.
-     */
-    readonly numChangedRows?: bigint;
-    /**
-     * This is defined for insert queries on dialects that return
-     * the auto incrementing primary key from an insert.
-     */
-    readonly insertId?: bigint;
-    /**
-     * The rows returned by the query. This is always defined and is
-     * empty if the query returned no rows.
-     */
-    readonly rows: O[];
-}

package/dist/esm/driver/default-connection-provider.d.ts

@@ -1,12 +0,0 @@
-import type { DatabaseConnection } from './database-connection.js';
-import type { ConnectionProvider } from './connection-provider.js';
-import type { Driver } from './driver.js';
-export declare class DefaultConnectionProvider implements ConnectionProvider {
-    #private;
-    constructor(driver: Driver);
-    /**
-     * Provides a connection for the callback and takes care of disposing
-     * the connection after the callback has been run.
-     */
-    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
-}

package/dist/esm/driver/default-connection-provider.js

@@ -1,16 +0,0 @@
-/// <reference types="./default-connection-provider.d.ts" />
-export class DefaultConnectionProvider {
-    #driver;
-    constructor(driver) {
-        this.#driver = driver;
-    }
-    async provideConnection(consumer) {
-        const connection = await this.#driver.acquireConnection();
-        try {
-            return await consumer(connection);
-        }
-        finally {
-            await this.#driver.releaseConnection(connection);
-        }
-    }
-}

package/dist/esm/driver/driver.d.ts

@@ -1,61 +0,0 @@
-import type { QueryCompiler } from '../query-compiler/query-compiler.js';
-import type { ArrayItemType } from '../util/type-utils.js';
-import type { DatabaseConnection } from './database-connection.js';
-/**
- * A Driver creates and releases {@link DatabaseConnection | database connections}
- * and is also responsible for connection pooling (if the dialect supports pooling).
- */
-export interface Driver {
-    /**
-     * Initializes the driver.
-     *
-     * After calling this method the driver should be usable and `acquireConnection` etc.
-     * methods should be callable.
-     */
-    init(): Promise<void>;
-    /**
-     * Acquires a new connection from the pool.
-     */
-    acquireConnection(): Promise<DatabaseConnection>;
-    /**
-     * Begins a transaction.
-     */
-    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
-    /**
-     * Commits a transaction.
-     */
-    commitTransaction(connection: DatabaseConnection): Promise<void>;
-    /**
-     * Rolls back a transaction.
-     */
-    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
-    /**
-     * Establishses a new savepoint within a transaction.
-     */
-    savepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    /**
-     * Rolls back to a savepoint within a transaction.
-     */
-    rollbackToSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    /**
-     * Releases a savepoint within a transaction.
-     */
-    releaseSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    /**
-     * Releases a connection back to the pool.
-     */
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
-    /**
-     * Destroys the driver and releases all resources.
-     */
-    destroy(): Promise<void>;
-}
-export interface TransactionSettings {
-    readonly accessMode?: AccessMode;
-    readonly isolationLevel?: IsolationLevel;
-}
-export declare const TRANSACTION_ACCESS_MODES: readonly ["read only", "read write"];
-export type AccessMode = ArrayItemType<typeof TRANSACTION_ACCESS_MODES>;
-export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
-export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
-export declare function validateTransactionSettings(settings: TransactionSettings): void;

package/dist/esm/driver/dummy-driver.d.ts

@@ -1,75 +0,0 @@
-import type { DatabaseConnection } from './database-connection.js';
-import type { Driver } from './driver.js';
-/**
- * A driver that does absolutely nothing.
- *
- * You can use this to create Kysely instances solely for building queries
- *
- * ### Examples
- *
- * This example creates a Kysely instance for building postgres queries:
- *
- * ```ts
- * import {
- *   DummyDriver,
- *   Kysely,
- *   PostgresAdapter,
- *   PostgresIntrospector,
- *   PostgresQueryCompiler
- * } from 'kysely'
- * import type { Database } from 'type-editor' // imaginary module
- *
- * const db = new Kysely<Database>({
- *   dialect: {
- *     createAdapter: () => new PostgresAdapter(),
- *     createDriver: () => new DummyDriver(),
- *     createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
- *     createQueryCompiler: () => new PostgresQueryCompiler(),
- *   },
- * })
- * ```
- *
- * You can use it to build a query and compile it to SQL but trying to
- * execute the query will throw an error.
- *
- * ```ts
- * const { sql } = db.selectFrom('person').selectAll().compile()
- * console.log(sql) // select * from "person"
- * ```
- */
-export declare class DummyDriver implements Driver {
-    /**
-     * Initializes the driver.
-     *
-     * After calling this method the driver should be usable and `acquireConnection` etc.
-     * methods should be callable.
-     */
-    init(): Promise<void>;
-    /**
-     * Acquires a new connection from the pool.
-     */
-    acquireConnection(): Promise<DatabaseConnection>;
-    /**
-     * Begins a transaction.
-     */
-    beginTransaction(): Promise<void>;
-    /**
-     * Commits a transaction.
-     */
-    commitTransaction(): Promise<void>;
-    /**
-     * Rolls back a transaction.
-     */
-    rollbackTransaction(): Promise<void>;
-    /**
-     * Releases a connection back to the pool.
-     */
-    releaseConnection(): Promise<void>;
-    /**
-     * Destroys the driver and releases all resources.
-     */
-    destroy(): Promise<void>;
-    releaseSavepoint(): Promise<void>;
-    rollbackToSavepoint(): Promise<void>;
-    savepoint(): Promise<void>;
-}

package/dist/esm/driver/runtime-driver.d.ts

@@ -1,47 +0,0 @@
-import type { QueryCompiler } from '../query-compiler/query-compiler.js';
-import type { Log } from '../util/log.js';
-import type { DatabaseConnection } from './database-connection.js';
-import type { Driver, TransactionSettings } from './driver.js';
-/**
- * A small wrapper around {@link Driver} that makes sure the driver is
- * initialized before it is used, only initialized and destroyed
- * once etc.
- */
-export declare class RuntimeDriver implements Driver {
-    #private;
-    constructor(driver: Driver, log: Log);
-    /**
-     * Initializes the driver.
-     *
-     * After calling this method the driver should be usable and `acquireConnection` etc.
-     * methods should be callable.
-     */
-    init(): Promise<void>;
-    /**
-     * Acquires a new connection from the pool.
-     */
-    acquireConnection(): Promise<DatabaseConnection>;
-    /**
-     * Releases a connection back to the pool.
-     */
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
-    /**
-     * Begins a transaction.
-     */
-    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
-    /**
-     * Commits a transaction.
-     */
-    commitTransaction(connection: DatabaseConnection): Promise<void>;
-    /**
-     * Rolls back a transaction.
-     */
-    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
-    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    /**
-     * Destroys the driver and releases all resources.
-     */
-    destroy(): Promise<void>;
-}

package/dist/esm/driver/runtime-driver.js

@@ -1,162 +0,0 @@
-/// <reference types="./runtime-driver.d.ts" />
-import { performanceNow } from '../util/performance-now.js';
-/**
- * A small wrapper around {@link Driver} that makes sure the driver is
- * initialized before it is used, only initialized and destroyed
- * once etc.
- */
-export class RuntimeDriver {
-    #driver;
-    #log;
-    #initPromise;
-    #initDone;
-    #destroyPromise;
-    #connections = new WeakSet();
-    constructor(driver, log) {
-        this.#initDone = false;
-        this.#driver = driver;
-        this.#log = log;
-    }
-    async init() {
-        if (this.#destroyPromise) {
-            throw new Error('driver has already been destroyed');
-        }
-        if (!this.#initPromise) {
-            this.#initPromise = this.#driver
-                .init()
-                .then(() => {
-                this.#initDone = true;
-            })
-                .catch((err) => {
-                this.#initPromise = undefined;
-                return Promise.reject(err);
-            });
-        }
-        await this.#initPromise;
-    }
-    async acquireConnection() {
-        if (this.#destroyPromise) {
-            throw new Error('driver has already been destroyed');
-        }
-        if (!this.#initDone) {
-            await this.init();
-        }
-        const connection = await this.#driver.acquireConnection();
-        if (!this.#connections.has(connection)) {
-            if (this.#needsLogging()) {
-                this.#addLogging(connection);
-            }
-            this.#connections.add(connection);
-        }
-        return connection;
-    }
-    async releaseConnection(connection) {
-        await this.#driver.releaseConnection(connection);
-    }
-    beginTransaction(connection, settings) {
-        return this.#driver.beginTransaction(connection, settings);
-    }
-    commitTransaction(connection) {
-        return this.#driver.commitTransaction(connection);
-    }
-    rollbackTransaction(connection) {
-        return this.#driver.rollbackTransaction(connection);
-    }
-    savepoint(connection, savepointName, compileQuery) {
-        if (this.#driver.savepoint) {
-            return this.#driver.savepoint(connection, savepointName, compileQuery);
-        }
-        throw new Error('The `savepoint` method is not supported by this driver');
-    }
-    rollbackToSavepoint(connection, savepointName, compileQuery) {
-        if (this.#driver.rollbackToSavepoint) {
-            return this.#driver.rollbackToSavepoint(connection, savepointName, compileQuery);
-        }
-        throw new Error('The `rollbackToSavepoint` method is not supported by this driver');
-    }
-    releaseSavepoint(connection, savepointName, compileQuery) {
-        if (this.#driver.releaseSavepoint) {
-            return this.#driver.releaseSavepoint(connection, savepointName, compileQuery);
-        }
-        throw new Error('The `releaseSavepoint` method is not supported by this driver');
-    }
-    async destroy() {
-        if (!this.#initPromise) {
-            return;
-        }
-        await this.#initPromise;
-        if (!this.#destroyPromise) {
-            this.#destroyPromise = this.#driver.destroy().catch((err) => {
-                this.#destroyPromise = undefined;
-                return Promise.reject(err);
-            });
-        }
-        await this.#destroyPromise;
-    }
-    #needsLogging() {
-        return (this.#log.isLevelEnabled('query') || this.#log.isLevelEnabled('error'));
-    }
-    // This method monkey patches the database connection's executeQuery method
-    // by adding logging code around it. Monkey patching is not pretty, but it's
-    // the best option in this case.
-    #addLogging(connection) {
-        const executeQuery = connection.executeQuery;
-        const streamQuery = connection.streamQuery;
-        const dis = this;
-        connection.executeQuery = async (compiledQuery) => {
-            let caughtError;
-            const startTime = performanceNow();
-            try {
-                return await executeQuery.call(connection, compiledQuery);
-            }
-            catch (error) {
-                caughtError = error;
-                await dis.#logError(error, compiledQuery, startTime);
-                throw error;
-            }
-            finally {
-                if (!caughtError) {
-                    await dis.#logQuery(compiledQuery, startTime);
-                }
-            }
-        };
-        connection.streamQuery = async function* (compiledQuery, chunkSize) {
-            let caughtError;
-            const startTime = performanceNow();
-            try {
-                for await (const result of streamQuery.call(connection, compiledQuery, chunkSize)) {
-                    yield result;
-                }
-            }
-            catch (error) {
-                caughtError = error;
-                await dis.#logError(error, compiledQuery, startTime);
-                throw error;
-            }
-            finally {
-                if (!caughtError) {
-                    await dis.#logQuery(compiledQuery, startTime, true);
-                }
-            }
-        };
-    }
-    async #logError(error, compiledQuery, startTime) {
-        await this.#log.error(() => ({
-            level: 'error',
-            error,
-            query: compiledQuery,
-            queryDurationMillis: this.#calculateDurationMillis(startTime),
-        }));
-    }
-    async #logQuery(compiledQuery, startTime, isStream = false) {
-        await this.#log.query(() => ({
-            level: 'query',
-            isStream,
-            query: compiledQuery,
-            queryDurationMillis: this.#calculateDurationMillis(startTime),
-        }));
-    }
-    #calculateDurationMillis(startTime) {
-        return performanceNow() - startTime;
-    }
-}

package/dist/esm/driver/single-connection-provider.d.ts

@@ -1,11 +0,0 @@
-import type { DatabaseConnection } from './database-connection.js';
-import type { ConnectionProvider } from './connection-provider.js';
-export declare class SingleConnectionProvider implements ConnectionProvider {
-    #private;
-    constructor(connection: DatabaseConnection);
-    /**
-     * Provides a connection for the callback and takes care of disposing
-     * the connection after the callback has been run.
-     */
-    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
-}

package/dist/esm/dynamic/dynamic-reference-builder.d.ts

@@ -1,18 +0,0 @@
-import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
-import type { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
-export declare class DynamicReferenceBuilder<R extends string = never> implements OperationNodeSource {
-    #private;
-    get dynamicReference(): string;
-    /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param R
-     * which causes this type to be equal to DynamicReferenceBuilder with
-     * any R.
-     */
-    protected get refType(): R;
-    constructor(reference: string);
-    toOperationNode(): SimpleReferenceExpressionNode;
-}
-export declare function isDynamicReferenceBuilder(obj: unknown): obj is DynamicReferenceBuilder<any>;

package/dist/esm/dynamic/dynamic-table-builder.d.ts

@@ -1,16 +0,0 @@
-import { AliasNode } from '../operation-node/alias-node.js';
-import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
-export declare class DynamicTableBuilder<T extends string> {
-    #private;
-    get table(): T;
-    constructor(table: T);
-    as<A extends string>(alias: A): AliasedDynamicTableBuilder<T, A>;
-}
-export declare class AliasedDynamicTableBuilder<T extends string, A extends string> implements OperationNodeSource {
-    #private;
-    get table(): T;
-    get alias(): A;
-    constructor(table: T, alias: A);
-    toOperationNode(): AliasNode;
-}
-export declare function isAliasedDynamicTableBuilder(obj: unknown): obj is AliasedDynamicTableBuilder<any, any>;