kysely 0.28.17 → 0.29.0

package/dist/dialect/postgres/postgres-introspector.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { Kysely } from '../../kysely.js';
+export declare class PostgresIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    /**
+     * Get schema metadata.
+     */
+    getSchemas(): Promise<SchemaMetadata[]>;
+    /**
+     * Get tables and views metadata.
+     */
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+}

package/dist/dialect/postgres/postgres-introspector.js

@@ -0,0 +1,102 @@
+/// <reference types="./postgres-introspector.d.ts" />
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { freeze } from '../../util/object-utils.js';
+import { sql } from '../../raw-builder/sql.js';
+export class PostgresIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getSchemas() {
+        let rawSchemas = await this.#db
+            .selectFrom('pg_catalog.pg_namespace')
+            .select('nspname')
+            .$castTo()
+            .execute();
+        return rawSchemas.map((it) => ({ name: it.nspname }));
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        let query = this.#db
+            // column
+            .selectFrom('pg_catalog.pg_attribute as a')
+            // table
+            .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
+            // table schema
+            .innerJoin('pg_catalog.pg_namespace as ns', 'c.relnamespace', 'ns.oid')
+            // column data type
+            .innerJoin('pg_catalog.pg_type as typ', 'a.atttypid', 'typ.oid')
+            // column data type schema
+            .innerJoin('pg_catalog.pg_namespace as dtns', 'typ.typnamespace', 'dtns.oid')
+            .select([
+            'a.attname as column',
+            'a.attnotnull as not_null',
+            'a.atthasdef as has_default',
+            'c.relname as table',
+            'c.relkind as table_type',
+            'ns.nspname as schema',
+            'typ.typname as type',
+            'dtns.nspname as type_schema',
+            sql `col_description(a.attrelid, a.attnum)`.as('column_description'),
+            sql `pg_get_serial_sequence(quote_ident(ns.nspname) || '.' || quote_ident(c.relname), a.attname)`.as('auto_incrementing'),
+        ])
+            .where('c.relkind', 'in', [
+            'r' /*regular table*/,
+            'v' /*view*/,
+            'p' /*partitioned table*/,
+            'f' /*foreign table*/,
+        ])
+            .where('ns.nspname', '!~', '^pg_')
+            .where('ns.nspname', '!=', 'information_schema')
+            // Filter out internal cockroachdb schema
+            .where('ns.nspname', '!=', 'crdb_internal')
+            // Only schemas where we are allowed access
+            .where(sql `has_schema_privilege(ns.nspname, 'USAGE')`)
+            // No system columns
+            .where('a.attnum', '>=', 0)
+            .where('a.attisdropped', '!=', true)
+            .orderBy('ns.nspname')
+            .orderBy('c.relname')
+            .orderBy('a.attnum')
+            .$castTo();
+        if (!options.withInternalKyselyTables) {
+            query = query
+                .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('c.relname', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+        }
+        const rawColumns = await query.execute();
+        return this.#parseTableMetadata(rawColumns);
+    }
+    #parseTableMetadata(columns) {
+        const tables = [];
+        const schemas = new Map();
+        for (const column of columns) {
+            let schema = schemas.get(column.schema);
+            if (!schema) {
+                schema = new Map();
+                schemas.set(column.schema, schema);
+            }
+            let table = schema.get(column.table);
+            if (!table) {
+                table = freeze({
+                    columns: [],
+                    isForeign: column.table_type === 'f',
+                    isView: column.table_type === 'v',
+                    name: column.table,
+                    schema: column.schema,
+                });
+                schema.set(column.table, table);
+                tables.push(table);
+            }
+            table.columns.push(freeze({
+                comment: column.column_description ?? undefined,
+                dataType: column.type,
+                dataTypeSchema: column.type_schema,
+                hasDefaultValue: column.has_default,
+                isAutoIncrementing: column.auto_incrementing !== null,
+                isNullable: !column.not_null,
+                name: column.column,
+            }));
+        }
+        return tables;
+    }
+}

package/dist/dialect/sqlite/sqlite-adapter.d.ts

@@ -0,0 +1,72 @@
+import type { Kysely } from '../../kysely.js';
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+import type { MigrationLockOptions } from '../dialect-adapter.js';
+export declare class SqliteAdapter extends DialectAdapterBase {
+    get supportsMultipleConnections(): boolean;
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration operations to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
+     * }
+     * ```
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
+    acquireMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
+    releaseMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
+}

package/dist/dialect/sqlite/sqlite-adapter.js

@@ -0,0 +1,23 @@
+/// <reference types="./sqlite-adapter.d.ts" />
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export class SqliteAdapter extends DialectAdapterBase {
+    get supportsMultipleConnections() {
+        return false;
+    }
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return true;
+    }
+    async acquireMigrationLock(_db, _opt) {
+        // SQLite only has one connection that's reserved by the migration system
+        // for the whole time between acquireMigrationLock and releaseMigrationLock.
+        // We don't need to do anything here.
+    }
+    async releaseMigrationLock(_db, _opt) {
+        // SQLite only has one connection that's reserved by the migration system
+        // for the whole time between acquireMigrationLock and releaseMigrationLock.
+        // We don't need to do anything here.
+    }
+}

package/dist/dialect/sqlite/sqlite-dialect-config.d.ts

@@ -0,0 +1,42 @@
+import type { DatabaseConnection } from '../../driver/database-connection.js';
+import type { AbortableOperationOptions } from '../../util/abort.js';
+/**
+ * Config for the SQLite dialect.
+ */
+export interface SqliteDialectConfig {
+    /**
+     * An sqlite Database instance or a function that returns one.
+     *
+     * If a function is provided, it's called once when the first query is executed.
+     *
+     * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+     */
+    database: SqliteDatabase | ((options?: AbortableOperationOptions) => Promise<SqliteDatabase>);
+    /**
+     * Called once when the first query is executed.
+     *
+     * This is a Kysely specific feature and does not come from the `better-sqlite3` module.
+     */
+    onCreateConnection?: (connection: DatabaseConnection, options?: AbortableOperationOptions) => Promise<void>;
+}
+/**
+ * This interface is the subset of better-sqlite3 driver's `Database` class that
+ * kysely needs.
+ *
+ * We don't use the type from `better-sqlite3` here to not have a dependency to it.
+ *
+ * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+ */
+export interface SqliteDatabase {
+    close(): void;
+    prepare(sql: string): SqliteStatement;
+}
+export interface SqliteStatement {
+    readonly reader: boolean;
+    all(parameters: ReadonlyArray<unknown>): unknown[];
+    run(parameters: ReadonlyArray<unknown>): {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    };
+    iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown>;
+}

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

@@ -0,0 +1,43 @@
+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 { AbortableOperationOptions } from '../../util/abort.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(options?: AbortableOperationOptions): 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/dialect/sqlite/sqlite-driver.js

@@ -0,0 +1,84 @@
+/// <reference types="./sqlite-driver.d.ts" />
+import { SelectQueryNode } from '../../operation-node/select-query-node.js';
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { freeze, isFunction } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
+export class SqliteDriver {
+    #config;
+    #db;
+    #connection;
+    constructor(config) {
+        this.#config = freeze({ ...config });
+    }
+    async init(options) {
+        this.#db = isFunction(this.#config.database)
+            ? await this.#config.database(options)
+            : this.#config.database;
+        this.#connection = new SqliteConnection(this.#db);
+        if (this.#config.onCreateConnection) {
+            await this.#config.onCreateConnection(this.#connection, options);
+        }
+    }
+    async acquireConnection() {
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('begin'));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
+    async releaseConnection() {
+        // noop
+    }
+    async destroy() {
+        this.#db?.close();
+    }
+}
+class SqliteConnection {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (stmt.reader) {
+            return {
+                rows: stmt.all(parameters),
+            };
+        }
+        const { changes, lastInsertRowid } = stmt.run(parameters);
+        return {
+            insertId: lastInsertRowid != null ? BigInt(lastInsertRowid) : undefined,
+            numAffectedRows: changes != null ? BigInt(changes) : undefined,
+            rows: [],
+        };
+    }
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const { sql, parameters, query } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (!SelectQueryNode.is(query)) {
+            throw new Error('Sqlite driver only supports streaming of select queries');
+        }
+        const iter = stmt.iterate(parameters);
+        for (const row of iter) {
+            yield {
+                rows: [row],
+            };
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { DatabaseIntrospector, 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[]>;
+}

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

@@ -0,0 +1,87 @@
+/// <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);
+    }
+    #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',
+                isForeign: false,
+                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/driver/connection-mutex.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This mutex is used to ensure that only one operation at a time can
+ * acquire a connection from the driver. This is necessary when the
+ * driver only has a single connection, like SQLite and PGlite.
+ *
+ * @internal
+ */
+export declare class ConnectionMutex {
+    #private;
+    obtainLock(): Promise<void>;
+    releaseLock(): void;
+}

package/dist/driver/connection-mutex.js

@@ -0,0 +1,26 @@
+/// <reference types="./connection-mutex.d.ts" />
+/**
+ * This mutex is used to ensure that only one operation at a time can
+ * acquire a connection from the driver. This is necessary when the
+ * driver only has a single connection, like SQLite and PGlite.
+ *
+ * @internal
+ */
+export class ConnectionMutex {
+    #promise;
+    #resolve;
+    async obtainLock() {
+        while (this.#promise) {
+            await this.#promise;
+        }
+        this.#promise = new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+    releaseLock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { DatabaseConnection } from './database-connection.js';
+import type { AbortableOperationOptions } from '../util/abort.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>, options?: AbortableOperationOptions): Promise<T>;
+}

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

@@ -0,0 +1,49 @@
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { AbortableOperationOptions } from '../util/abort.js';
+/**
+ * A single connection to the database engine.
+ *
+ * These are created by an instance of {@link Driver}.
+ */
+export interface DatabaseConnection {
+    /**
+     * Used by executors to cancel the inflight query on the database side.
+     */
+    cancelQuery?(controlConnectionProvider: ControlConnectionProvider): Promise<void>;
+    /**
+     * Used by executors to prepare the connection for operations on the database side.
+     */
+    collectSessionInfo?(): Promise<void>;
+    executeQuery<R>(compiledQuery: CompiledQuery, options?: AbortableOperationOptions): Promise<QueryResult<R>>;
+    /**
+     * Used by executors to kill the session on the database side.
+     */
+    killSession?(controlConnectionProvider: ControlConnectionProvider): Promise<void>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize: number, options?: AbortableOperationOptions): AsyncIterableIterator<QueryResult<R>>;
+}
+export type ControlConnectionProvider = (consumer: (connection: DatabaseConnection) => Promise<void>) => Promise<void>;
+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/driver/default-connection-provider.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseConnection } from './database-connection.js';
+import type { ConnectionProvider } from './connection-provider.js';
+import type { Driver } from './driver.js';
+import type { AbortableOperationOptions } from '../util/abort.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>, options?: AbortableOperationOptions): Promise<T>;
+}

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

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