kysely 0.26.3 → 0.27.0

package/dist/esm/dialect/mssql/mssql-driver.js

@@ -0,0 +1,265 @@
+/// <reference types="./mssql-driver.d.ts" />
+import { freeze, isBigInt, isBoolean, isBuffer, isDate, isNull, isNumber, isString, isUndefined, } from '../../util/object-utils.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { extendStackTrace } from '../../util/stack-trace-utils.js';
+import { randomString } from '../../util/random-string.js';
+import { Deferred } from '../../util/deferred.js';
+const PRIVATE_RELEASE_METHOD = Symbol();
+const PRIVATE_DESTROY_METHOD = Symbol();
+export class MssqlDriver {
+    #config;
+    #pool;
+    constructor(config) {
+        this.#config = freeze({ ...config });
+        this.#pool = new this.#config.tarn.Pool({
+            ...this.#config.tarn.options,
+            create: async () => {
+                const connection = await this.#config.tedious.connectionFactory();
+                await new Promise((resolve, reject) => connection.connect((error) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(undefined);
+                }));
+                return new MssqlConnection(connection, this.#config.tedious);
+            },
+            destroy: async (connection) => {
+                await connection[PRIVATE_DESTROY_METHOD]();
+            },
+            // @ts-ignore `tarn` accepts a function that returns a promise here, but
+            // the types are not aligned and it type errors.
+            validate: (connection) => connection.validate(),
+        });
+    }
+    async init() {
+        // noop
+    }
+    async acquireConnection() {
+        return await this.#pool.acquire().promise;
+    }
+    async beginTransaction(connection, settings) {
+        await connection.beginTransaction(settings);
+    }
+    async commitTransaction(connection) {
+        await connection.commitTransaction();
+    }
+    async rollbackTransaction(connection) {
+        await connection.rollbackTransaction();
+    }
+    async releaseConnection(connection) {
+        await connection[PRIVATE_RELEASE_METHOD]();
+        this.#pool.release(connection);
+    }
+    async destroy() {
+        await this.#pool.destroy();
+    }
+}
+class MssqlConnection {
+    #connection;
+    #tedious;
+    constructor(connection, tedious) {
+        this.#connection = connection;
+        this.#tedious = tedious;
+    }
+    async beginTransaction(settings) {
+        const { isolationLevel } = settings;
+        await new Promise((resolve, reject) => this.#connection.beginTransaction((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve(undefined);
+        }, isolationLevel ? randomString(8) : undefined, isolationLevel
+            ? this.#getTediousIsolationLevel(isolationLevel)
+            : undefined));
+    }
+    async commitTransaction() {
+        await new Promise((resolve, reject) => this.#connection.commitTransaction((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve(undefined);
+        }));
+    }
+    async executeQuery(compiledQuery) {
+        try {
+            const deferred = new Deferred();
+            const request = new MssqlRequest(this.#tedious, compiledQuery, deferred);
+            this.#connection.execSql(request.request);
+            const { rowCount, rows } = await deferred.promise;
+            return {
+                numAffectedRows: rowCount !== undefined ? BigInt(rowCount) : undefined,
+                rows,
+            };
+        }
+        catch (err) {
+            throw extendStackTrace(err, new Error());
+        }
+    }
+    async rollbackTransaction() {
+        await new Promise((resolve, reject) => this.#connection.rollbackTransaction((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve(undefined);
+        }));
+    }
+    async *streamQuery(compiledQuery, chunkSize) {
+        if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+            throw new Error('chunkSize must be a positive integer');
+        }
+        const request = new MssqlRequest(this.#tedious, compiledQuery);
+        this.#connection.execSql(request.request);
+        try {
+            while (true) {
+                const rows = await request.readChunk(chunkSize);
+                if (rows.length === 0) {
+                    break;
+                }
+                yield { rows };
+                if (rows.length < chunkSize) {
+                    break;
+                }
+            }
+        }
+        finally {
+            this.#connection.cancel();
+        }
+    }
+    async validate() {
+        try {
+            const deferred = new Deferred();
+            const request = new MssqlRequest(this.#tedious, CompiledQuery.raw('select 1'), deferred);
+            this.#connection.execSql(request.request);
+            await deferred.promise;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    #getTediousIsolationLevel(isolationLevel) {
+        const { ISOLATION_LEVEL } = this.#tedious;
+        const mapper = {
+            'read committed': ISOLATION_LEVEL.READ_COMMITTED,
+            'read uncommitted': ISOLATION_LEVEL.READ_UNCOMMITTED,
+            'repeatable read': ISOLATION_LEVEL.REPEATABLE_READ,
+            serializable: ISOLATION_LEVEL.SERIALIZABLE,
+            snapshot: ISOLATION_LEVEL.SNAPSHOT,
+        };
+        const tediousIsolationLevel = mapper[isolationLevel];
+        if (tediousIsolationLevel === undefined) {
+            throw new Error(`Unknown isolation level: ${isolationLevel}`);
+        }
+        return tediousIsolationLevel;
+    }
+    [PRIVATE_RELEASE_METHOD]() {
+        return new Promise((resolve, reject) => {
+            this.#connection.reset((error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(undefined);
+            });
+        });
+    }
+    [PRIVATE_DESTROY_METHOD]() {
+        return new Promise((resolve) => {
+            this.#connection.once('end', () => {
+                resolve(undefined);
+            });
+            this.#connection.close();
+        });
+    }
+}
+class MssqlRequest {
+    #request;
+    #rows;
+    #tedious;
+    #completed;
+    #error;
+    #rowCount;
+    constructor(tedious, compiledQuery, onDone) {
+        this.#completed = false;
+        this.#rows = [];
+        this.#tedious = tedious;
+        const { parameters, sql } = compiledQuery;
+        this.#request = new this.#tedious.Request(sql, (err, rowCount) => {
+            if (err) {
+                this.#error = err instanceof AggregateError ? err.errors : err;
+                onDone?.reject(this.#error);
+            }
+            else {
+                this.#rowCount = rowCount;
+            }
+        });
+        this.#addParametersToRequest(parameters);
+        this.#attachListeners(onDone);
+    }
+    get request() {
+        return this.#request;
+    }
+    readChunk(chunkSize) {
+        return new Promise((resolve, reject) => {
+            const interval = setInterval(() => {
+                if (this.#error) {
+                    clearInterval(interval);
+                    reject(this.#error);
+                }
+                else if (this.#completed || this.#rows.length >= chunkSize) {
+                    clearInterval(interval);
+                    resolve(this.#rows.splice(0, chunkSize));
+                }
+            }, 0);
+        });
+    }
+    #addParametersToRequest(parameters) {
+        for (let i = 0; i < parameters.length; i++) {
+            const parameter = parameters[i];
+            this.#request.addParameter(String(i + 1), this.#getTediousDataType(parameter), parameter);
+        }
+    }
+    #attachListeners(onDone) {
+        const rowListener = (columns) => {
+            const row = {};
+            for (const column of columns) {
+                row[column.metadata.colName] = column.value;
+            }
+            this.#rows.push(row);
+        };
+        this.#request.on('row', rowListener);
+        this.#request.once('requestCompleted', () => {
+            this.#completed = true;
+            this.#request.off('row', rowListener);
+            onDone?.resolve({
+                rowCount: this.#rowCount,
+                rows: this.#rows,
+            });
+        });
+    }
+    #getTediousDataType(value) {
+        if (isNull(value) || isUndefined(value) || isString(value)) {
+            return this.#tedious.TYPES.NVarChar;
+        }
+        if (isBigInt(value) || (isNumber(value) && value % 1 === 0)) {
+            if (value < -2147483648 || value > 2147483647) {
+                return this.#tedious.TYPES.BigInt;
+            }
+            else {
+                return this.#tedious.TYPES.Int;
+            }
+        }
+        if (isNumber(value)) {
+            return this.#tedious.TYPES.Float;
+        }
+        if (isBoolean(value)) {
+            return this.#tedious.TYPES.Bit;
+        }
+        if (isDate(value)) {
+            return this.#tedious.TYPES.DateTime;
+        }
+        if (isBuffer(value)) {
+            return this.#tedious.TYPES.VarBinary;
+        }
+        return this.#tedious.TYPES.NVarChar;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { Kysely } from '../../kysely.js';
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+export declare class MssqlIntrospector 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/mssql/mssql-introspector.js

@@ -0,0 +1,94 @@
+/// <reference types="./mssql-introspector.d.ts" />
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { freeze } from '../../util/object-utils.js';
+export class MssqlIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getSchemas() {
+        return await this.#db.selectFrom('sys.schemas').select('name').execute();
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        const rawColumns = await this.#db
+            .selectFrom('sys.tables as tables')
+            .leftJoin('sys.schemas as table_schemas', 'table_schemas.schema_id', 'tables.schema_id')
+            .innerJoin('sys.columns as columns', 'columns.object_id', 'tables.object_id')
+            .innerJoin('sys.types as types', 'types.system_type_id', 'columns.system_type_id')
+            .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
+            .$if(!options.withInternalKyselyTables, (qb) => qb
+            .where('tables.name', '!=', DEFAULT_MIGRATION_TABLE)
+            .where('tables.name', '!=', DEFAULT_MIGRATION_LOCK_TABLE))
+            .select([
+            'tables.name as table_name',
+            (eb) => eb
+                .ref('tables.type')
+                .$castTo()
+                .as('table_type'),
+            'table_schemas.name as table_schema_name',
+            'columns.default_object_id as column_default_object_id',
+            'columns.generated_always_type_desc as column_generated_always_type',
+            'columns.is_computed as column_is_computed',
+            'columns.is_identity as column_is_identity',
+            'columns.is_nullable as column_is_nullable',
+            'columns.is_rowguidcol as column_is_rowguidcol',
+            'columns.name as column_name',
+            'types.is_nullable as type_is_nullable',
+            'types.name as type_name',
+            'type_schemas.name as type_schema_name',
+        ])
+            .unionAll(this.#db
+            .selectFrom('sys.views as views')
+            .leftJoin('sys.schemas as view_schemas', 'view_schemas.schema_id', 'views.schema_id')
+            .innerJoin('sys.columns as columns', 'columns.object_id', 'views.object_id')
+            .innerJoin('sys.types as types', 'types.system_type_id', 'columns.system_type_id')
+            .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
+            .select([
+            'views.name as table_name',
+            'views.type as table_type',
+            'view_schemas.name as table_schema_name',
+            'columns.default_object_id as column_default_object_id',
+            'columns.generated_always_type_desc as column_generated_always_type',
+            'columns.is_computed as column_is_computed',
+            'columns.is_identity as column_is_identity',
+            'columns.is_nullable as column_is_nullable',
+            'columns.is_rowguidcol as column_is_rowguidcol',
+            'columns.name as column_name',
+            'types.is_nullable as type_is_nullable',
+            'types.name as type_name',
+            'type_schemas.name as type_schema_name',
+        ]))
+            .orderBy('table_schema_name')
+            .orderBy('table_name')
+            .orderBy('column_name')
+            .execute();
+        const tableDictionary = {};
+        for (const rawColumn of rawColumns) {
+            const key = `${rawColumn.table_schema_name}.${rawColumn.table_name}`;
+            const table = (tableDictionary[key] ||= freeze({
+                columns: [],
+                isView: rawColumn.table_type === 'V ',
+                name: rawColumn.table_name,
+                schema: rawColumn.table_schema_name ?? undefined,
+            }));
+            table.columns.push(freeze({
+                dataType: rawColumn.type_name,
+                dataTypeSchema: rawColumn.type_schema_name ?? undefined,
+                hasDefaultValue: rawColumn.column_default_object_id > 0 ||
+                    rawColumn.column_generated_always_type !== 'NOT_APPLICABLE' ||
+                    rawColumn.column_is_identity ||
+                    rawColumn.column_is_computed ||
+                    rawColumn.column_is_rowguidcol,
+                isAutoIncrementing: rawColumn.column_is_identity,
+                isNullable: rawColumn.column_is_nullable && rawColumn.type_is_nullable,
+                name: rawColumn.column_name,
+            }));
+        }
+        return Object.values(tableDictionary);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AddColumnNode } from '../../operation-node/add-column-node.js';
+import { AlterTableColumnAlterationNode } from '../../operation-node/alter-table-node.js';
+import { DropColumnNode } from '../../operation-node/drop-column-node.js';
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export declare class MssqlQueryCompiler extends DefaultQueryCompiler {
+    protected getCurrentParameterPlaceholder(): string;
+    protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
+    protected visitAddColumn(node: AddColumnNode): void;
+    protected visitDropColumn(node: DropColumnNode): void;
+    protected announcesNewColumnDataType(): boolean;
+}

package/dist/esm/dialect/mssql/mssql-query-compiler.js

@@ -0,0 +1,61 @@
+/// <reference types="./mssql-query-compiler.d.ts" />
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export class MssqlQueryCompiler extends DefaultQueryCompiler {
+    getCurrentParameterPlaceholder() {
+        return `@${this.numParameters}`;
+    }
+    // mssql allows multi-column alterations in a single statement,
+    // but you can only use the command keyword/s once.
+    // it also doesn't support multiple kinds of commands in the same
+    // alter table statement, but we compile that anyway for the sake
+    // of WYSIWYG.
+    compileColumnAlterations(columnAlterations) {
+        const nodesByKind = {};
+        for (const columnAlteration of columnAlterations) {
+            if (!nodesByKind[columnAlteration.kind]) {
+                nodesByKind[columnAlteration.kind] = [];
+            }
+            nodesByKind[columnAlteration.kind].push(columnAlteration);
+        }
+        let first = true;
+        if (nodesByKind.AddColumnNode) {
+            this.append('add ');
+            this.compileList(nodesByKind.AddColumnNode);
+            first = false;
+        }
+        // multiple of these are not really supported by mssql,
+        // but for the sake of WYSIWYG.
+        if (nodesByKind.AlterColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.compileList(nodesByKind.AlterColumnNode);
+        }
+        if (nodesByKind.DropColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.append('drop column ');
+            this.compileList(nodesByKind.DropColumnNode);
+        }
+        // not really supported by mssql, but for the sake of WYSIWYG.
+        if (nodesByKind.ModifyColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.compileList(nodesByKind.ModifyColumnNode);
+        }
+        // not really supported by mssql, but for the sake of WYSIWYG.
+        if (nodesByKind.RenameColumnNode) {
+            if (!first)
+                this.append(', ');
+            this.compileList(nodesByKind.RenameColumnNode);
+        }
+    }
+    visitAddColumn(node) {
+        this.visitNode(node.column);
+    }
+    visitDropColumn(node) {
+        this.visitNode(node.column);
+    }
+    announcesNewColumnDataType() {
+        return false;
+    }
+}

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

@@ -1,3 +1,4 @@
+import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
@@ -8,4 +9,5 @@ export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected sanitizeIdentifier(identifier: string): string;
+    protected visitCreateIndex(node: CreateIndexNode): void;
 }

package/dist/esm/dialect/mysql/mysql-query-compiler.js

@@ -26,4 +26,32 @@ export class MysqlQueryCompiler extends DefaultQueryCompiler {
     sanitizeIdentifier(identifier) {
         return identifier.replace(ID_WRAP_REGEX, '``');
     }
+    visitCreateIndex(node) {
+        this.append('create ');
+        if (node.unique) {
+            this.append('unique ');
+        }
+        this.append('index ');
+        if (node.ifNotExists) {
+            this.append('if not exists ');
+        }
+        this.visitNode(node.name);
+        if (node.using) {
+            this.append(' using ');
+            this.visitNode(node.using);
+        }
+        if (node.table) {
+            this.append(' on ');
+            this.visitNode(node.table);
+        }
+        if (node.columns) {
+            this.append(' (');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+        if (node.where) {
+            this.append(' ');
+            this.visitNode(node.where);
+        }
+    }
 }

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -26,7 +26,7 @@ export class PostgresDriver {
             // The driver must take care of calling `onCreateConnection` when a new
             // connection is created. The `pg` module doesn't provide an async hook
             // for the connection creation. We need to call the method explicitly.
-            if (this.#config?.onCreateConnection) {
+            if (this.#config.onCreateConnection) {
                 await this.#config.onCreateConnection(connection);
             }
         }

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

@@ -1,7 +1,7 @@
 import { Kysely } from '../../kysely.js';
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
 import { MigrationLockOptions } from '../dialect-adapter.js';
-export declare class SqliteAdapter implements DialectAdapterBase {
+export declare class SqliteAdapter extends DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
      *

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

@@ -1,5 +1,6 @@
 /// <reference types="./sqlite-adapter.d.ts" />
-export class SqliteAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export class SqliteAdapter extends DialectAdapterBase {
     get supportsTransactionalDdl() {
         return false;
     }

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

@@ -37,4 +37,5 @@ export interface SqliteStatement {
         changes: number | bigint;
         lastInsertRowid: number | bigint;
     };
+    iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown>;
 }

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

@@ -1,4 +1,5 @@
 /// <reference types="./sqlite-driver.d.ts" />
+import { SelectQueryNode } from '../../operation-node/select-query-node.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { freeze, isFunction } from '../../util/object-utils.js';
 export class SqliteDriver {
@@ -67,8 +68,20 @@ class SqliteConnection {
             });
         }
     }
-    async *streamQuery() {
-        throw new Error("Sqlite driver doesn't support streaming");
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const { sql, parameters, query } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (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 {

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

@@ -40,5 +40,5 @@ export interface Driver {
 export interface TransactionSettings {
     readonly isolationLevel?: IsolationLevel;
 }
-export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable"];
+export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
 export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;

package/dist/esm/driver/driver.js

@@ -4,4 +4,5 @@ export const TRANSACTION_ISOLATION_LEVELS = [
     'read committed',
     'repeatable read',
     'serializable',
+    'snapshot',
 ];

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

@@ -84,16 +84,20 @@ export class RuntimeDriver {
     #addLogging(connection) {
         const executeQuery = connection.executeQuery;
         connection.executeQuery = async (compiledQuery) => {
+            let caughtError;
             const startTime = performanceNow();
             try {
                 return await executeQuery.call(connection, compiledQuery);
             }
             catch (error) {
+                caughtError = error;
                 await this.#logError(error, compiledQuery, startTime);
                 throw error;
             }
             finally {
-                await this.#logQuery(compiledQuery, startTime);
+                if (!caughtError) {
+                    await this.#logQuery(compiledQuery, startTime);
+                }
             }
         };
     }

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

@@ -1,4 +1,5 @@
 /// <reference types="./single-connection-provider.d.ts" />
+const ignoreError = () => { };
 export class SingleConnectionProvider {
     #connection;
     #runningPromise;
@@ -7,17 +8,15 @@ export class SingleConnectionProvider {
     }
     async provideConnection(consumer) {
         while (this.#runningPromise) {
-            await this.#runningPromise;
+            await this.#runningPromise.catch(ignoreError);
         }
-        const promise = this.#run(consumer);
-        this.#runningPromise = promise
-            .then(() => {
-            this.#runningPromise = undefined;
-        })
-            .catch(() => {
+        // `#runningPromise` must be set to undefined before it's
+        // resolved or rejected. Otherwise the while loop above
+        // will misbehave.
+        this.#runningPromise = this.#run(consumer).finally(() => {
             this.#runningPromise = undefined;
         });
-        return promise;
+        return this.#runningPromise;
     }
     // Run the runner in an async function to make sure it doesn't
     // throw synchronous errors.