kysely 0.28.17 → 0.29.0

package/dist/cjs/dialect/sqlite/sqlite-driver.d.ts

@@ -1,42 +0,0 @@
-import type { DatabaseConnection } from '../../driver/database-connection.js';
-import type { Driver } from '../../driver/driver.js';
-import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
-import type { SqliteDialectConfig } from './sqlite-dialect-config.js';
-export declare class SqliteDriver implements Driver {
-    #private;
-    constructor(config: SqliteDialectConfig);
-    /**
-     * 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): 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>;
-    /**
-     * Releases a connection back to the pool.
-     */
-    releaseConnection(): Promise<void>;
-    /**
-     * Destroys the driver and releases all resources.
-     */
-    destroy(): Promise<void>;
-}

package/dist/cjs/dialect/sqlite/sqlite-driver.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteDriver = void 0;
-const select_query_node_js_1 = require("../../operation-node/select-query-node.js");
-const savepoint_parser_js_1 = require("../../parser/savepoint-parser.js");
-const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
-const query_id_js_1 = require("../../util/query-id.js");
-class SqliteDriver {
-    #config;
-    #connectionMutex = new ConnectionMutex();
-    #db;
-    #connection;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
-    }
-    async init() {
-        this.#db = (0, object_utils_js_1.isFunction)(this.#config.database)
-            ? await this.#config.database()
-            : this.#config.database;
-        this.#connection = new SqliteConnection(this.#db);
-        if (this.#config.onCreateConnection) {
-            await this.#config.onCreateConnection(this.#connection);
-        }
-    }
-    async acquireConnection() {
-        // SQLite only has one single connection. We use a mutex here to wait
-        // until the single connection has been released.
-        await this.#connectionMutex.lock();
-        return this.#connection;
-    }
-    async beginTransaction(connection) {
-        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('begin'));
-    }
-    async commitTransaction(connection) {
-        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('commit'));
-    }
-    async rollbackTransaction(connection) {
-        await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
-    }
-    async savepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('savepoint', savepointName), (0, query_id_js_1.createQueryId)()));
-    }
-    async rollbackToSavepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('rollback to', savepointName), (0, query_id_js_1.createQueryId)()));
-    }
-    async releaseSavepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('release', savepointName), (0, query_id_js_1.createQueryId)()));
-    }
-    async releaseConnection() {
-        this.#connectionMutex.unlock();
-    }
-    async destroy() {
-        this.#db?.close();
-    }
-}
-exports.SqliteDriver = SqliteDriver;
-class SqliteConnection {
-    #db;
-    constructor(db) {
-        this.#db = db;
-    }
-    executeQuery(compiledQuery) {
-        const { sql, parameters } = compiledQuery;
-        const stmt = this.#db.prepare(sql);
-        if (stmt.reader) {
-            return Promise.resolve({
-                rows: stmt.all(parameters),
-            });
-        }
-        const { changes, lastInsertRowid } = stmt.run(parameters);
-        return Promise.resolve({
-            numAffectedRows: changes !== undefined && changes !== null ? BigInt(changes) : undefined,
-            insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
-                ? BigInt(lastInsertRowid)
-                : undefined,
-            rows: [],
-        });
-    }
-    async *streamQuery(compiledQuery, _chunkSize) {
-        const { sql, parameters, query } = compiledQuery;
-        const stmt = this.#db.prepare(sql);
-        if (select_query_node_js_1.SelectQueryNode.is(query)) {
-            const iter = stmt.iterate(parameters);
-            for (const row of iter) {
-                yield {
-                    rows: [row],
-                };
-            }
-        }
-        else {
-            throw new Error('Sqlite driver only supports streaming of select queries');
-        }
-    }
-}
-class ConnectionMutex {
-    #promise;
-    #resolve;
-    async lock() {
-        while (this.#promise) {
-            await this.#promise;
-        }
-        this.#promise = new Promise((resolve) => {
-            this.#resolve = resolve;
-        });
-    }
-    unlock() {
-        const resolve = this.#resolve;
-        this.#promise = undefined;
-        this.#resolve = undefined;
-        resolve?.();
-    }
-}

package/dist/cjs/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/cjs/dialect/sqlite/sqlite-introspector.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteIntrospector = void 0;
-const migrator_js_1 = require("../../migration/migrator.js");
-const sql_js_1 = require("../../raw-builder/sql.js");
-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', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
-                .where('name', '!=', migrator_js_1.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',
-            (0, sql_js_1.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,
-                })),
-            };
-        });
-    }
-}
-exports.SqliteIntrospector = SqliteIntrospector;

package/dist/cjs/dialect/sqlite/sqlite-query-compiler.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteQueryCompiler = void 0;
-const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
-const ID_WRAP_REGEX = /"/g;
-const JSON_PATH_MEMBER_ESCAPE_REGEX = /[\\'"]/g;
-class SqliteQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
-    visitOrAction(node) {
-        this.append('or ');
-        this.append(node.action);
-    }
-    getCurrentParameterPlaceholder() {
-        return '?';
-    }
-    getLeftExplainOptionsWrapper() {
-        return '';
-    }
-    getRightExplainOptionsWrapper() {
-        return '';
-    }
-    getLeftIdentifierWrapper() {
-        return '"';
-    }
-    getRightIdentifierWrapper() {
-        return '"';
-    }
-    getAutoIncrement() {
-        return 'autoincrement';
-    }
-    sanitizeIdentifier(identifier) {
-        return identifier.replace(ID_WRAP_REGEX, '""');
-    }
-    sanitizeJSONPathMemberValue(value) {
-        return value.replace(JSON_PATH_MEMBER_ESCAPE_REGEX, (char) => char === '\\' ? '\\\\' : char === "'" ? "''" : '\\"');
-    }
-    visitDefaultInsertValue(_) {
-        // sqlite doesn't support the `default` keyword in inserts.
-        this.append('null');
-    }
-}
-exports.SqliteQueryCompiler = SqliteQueryCompiler;

package/dist/cjs/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/cjs/driver/connection-provider.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/driver/database-connection.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/driver/default-connection-provider.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultConnectionProvider = void 0;
-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);
-        }
-    }
-}
-exports.DefaultConnectionProvider = DefaultConnectionProvider;

package/dist/cjs/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/cjs/driver/driver.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRANSACTION_ISOLATION_LEVELS = exports.TRANSACTION_ACCESS_MODES = void 0;
-exports.validateTransactionSettings = validateTransactionSettings;
-exports.TRANSACTION_ACCESS_MODES = ['read only', 'read write'];
-exports.TRANSACTION_ISOLATION_LEVELS = [
-    'read uncommitted',
-    'read committed',
-    'repeatable read',
-    'serializable',
-    'snapshot',
-];
-function validateTransactionSettings(settings) {
-    if (settings.accessMode &&
-        !exports.TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {
-        throw new Error(`invalid transaction access mode ${settings.accessMode}`);
-    }
-    if (settings.isolationLevel &&
-        !exports.TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
-        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
-    }
-}

package/dist/cjs/driver/dummy-driver.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DummyDriver = void 0;
-/**
- * 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"
- * ```
- */
-class DummyDriver {
-    async init() {
-        // Nothing to do here.
-    }
-    async acquireConnection() {
-        return new DummyConnection();
-    }
-    async beginTransaction() {
-        // Nothing to do here.
-    }
-    async commitTransaction() {
-        // Nothing to do here.
-    }
-    async rollbackTransaction() {
-        // Nothing to do here.
-    }
-    async releaseConnection() {
-        // Nothing to do here.
-    }
-    async destroy() {
-        // Nothing to do here.
-    }
-    async releaseSavepoint() {
-        // Nothing to do here.
-    }
-    async rollbackToSavepoint() {
-        // Nothing to do here.
-    }
-    async savepoint() {
-        // Nothing to do here.
-    }
-}
-exports.DummyDriver = DummyDriver;
-class DummyConnection {
-    async executeQuery() {
-        return {
-            rows: [],
-        };
-    }
-    async *streamQuery() {
-        // Nothing to do here.
-    }
-}

package/dist/cjs/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>;
-}