kysely 0.27.2 → 0.27.4

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

@@ -2,7 +2,7 @@ import { Kysely } from '../kysely.js';
 import { DialectAdapter, MigrationLockOptions } from './dialect-adapter.js';
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
- * 3rd party dialects can extend this instead of implementing the `DialectAdapter`
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
  * interface from scratch. That way all new settings will get default values when
  * they are added and there will be less breaking changes.
  */
@@ -26,6 +26,7 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * updates and deletes.
      */
     get supportsReturning(): boolean;
+    get supportsOutput(): 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.

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

@@ -1,7 +1,7 @@
 /// <reference types="./dialect-adapter-base.d.ts" />
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
- * 3rd party dialects can extend this instead of implementing the `DialectAdapter`
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
  * interface from scratch. That way all new settings will get default values when
  * they are added and there will be less breaking changes.
  */
@@ -15,4 +15,7 @@ export class DialectAdapterBase {
     get supportsReturning() {
         return false;
     }
+    get supportsOutput() {
+        return false;
+    }
 }

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

@@ -27,6 +27,11 @@ export interface DialectAdapter {
      * updates and deletes.
      */
     readonly supportsReturning: boolean;
+    /**
+     * Whether or not this dialect supports the `output` clause in inserts
+     * updates and deletes.
+     */
+    readonly supportsOutput?: 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.

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

@@ -15,11 +15,7 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      * If this is true, migrations are executed inside a transaction.
      */
     get supportsTransactionalDdl(): boolean;
-    /**
-     * Whether or not this dialect supports the `returning` in inserts
-     * updates and deletes.
-     */
-    get supportsReturning(): boolean;
+    get supportsOutput(): 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.

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

@@ -9,10 +9,8 @@ export class MssqlAdapter extends DialectAdapterBase {
     get supportsTransactionalDdl() {
         return true;
     }
-    get supportsReturning() {
-        // mssql should support returning with the `output` clause.
-        // we need to figure this out when we'll introduce support for it.
-        return false;
+    get supportsOutput() {
+        return true;
     }
     async acquireMigrationLock(db) {
         // Acquire a transaction-level exclusive lock on the migrations table.

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

@@ -50,39 +50,59 @@ export interface MssqlDialectConfig {
 export interface Tedious {
     connectionFactory: () => TediousConnection | Promise<TediousConnection>;
     ISOLATION_LEVEL: TediousIsolationLevel;
-    Request: typeof TediousRequest;
+    Request: TediousRequestClass;
     TYPES: TediousTypes;
 }
-export type TediousIsolationLevel = Record<'NO_CHANGE' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE' | 'SNAPSHOT', number>;
-export type TediousTypes = Record<'BigInt' | 'Binary' | 'Bit' | 'Char' | 'Date' | 'DateTime' | 'DateTime2' | 'DateTimeOffset' | 'Decimal' | 'Float' | 'Image' | 'Int' | 'Money' | 'NChar' | 'NText' | 'Null' | 'Numeric' | 'NVarChar' | 'Real' | 'SmallDateTime' | 'SmallInt' | 'SmallMoney' | 'Text' | 'Time' | 'TinyInt' | 'TVP' | 'UDT' | 'UniqueIdentifier' | 'VarBinary' | 'VarChar' | 'Xml', {
-    name: string;
-    type: string;
-}>;
-export interface TediousType {
-    name: string;
-    type: string;
-}
 export interface TediousConnection {
-    beginTransaction(callback: (error?: Error) => void, transactionId?: string | undefined, isolationLevel?: number | undefined): void;
-    cancel(): void;
+    beginTransaction(callback: (error?: Error | null, transactionDescriptor?: any) => void, name?: string, isolationLevel?: number): void;
+    cancel(): boolean;
     close(): void;
-    commitTransaction(callback: (error?: Error) => void): void;
-    connect(callback: (error?: Error) => void): void;
+    commitTransaction(callback: (error?: Error | null) => void, name?: string): void;
+    connect(callback?: (error?: Error) => void): void;
     execSql(request: TediousRequest): void;
-    reset(callback: (error?: Error) => void): void;
-    rollbackTransaction(callback: (error?: Error) => void): void;
-    once(event: 'end', listener: () => void): void;
+    off(event: 'error', listener: (error: unknown) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    on(event: 'error', listener: (error: unknown) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: 'end', listener: () => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    reset(callback: (error?: Error | null) => void): void;
+    rollbackTransaction(callback: (error?: Error | null) => void, name?: string): void;
+    saveTransaction(callback: (error?: Error | null) => void, name: string): void;
+}
+export type TediousIsolationLevel = Record<string, number>;
+export interface TediousRequestClass {
+    new (sqlTextOrProcedure: string | undefined, callback: (error?: Error | null, rowCount?: number, rows?: any) => void, options?: {
+        statementColumnEncryptionSetting?: any;
+    }): TediousRequest;
 }
 export declare class TediousRequest {
-    constructor(sql: string, callback: (error: Error, rowCount: number, rows: any[]) => void);
-    addParameter(name: string, type: TediousType, value: any, options?: {
-        length?: number | 'max' | undefined;
-        precision?: number | undefined;
-        scale?: number | undefined;
-    }): void;
-    off(event: 'row', listener: (...args: any[]) => void): void;
-    on(event: 'row', listener: (columns: TediousColumnValue[]) => void): void;
-    once(event: 'requestCompleted', listener: (...args: any[]) => void): void;
+    addParameter(name: string, dataType: TediousDataType, value?: unknown, options?: Readonly<{
+        output?: boolean;
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }> | null): void;
+    off(event: 'row', listener: (columns: any) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    on(event: 'row', listener: (columns: any) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: 'requestCompleted', listener: () => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    pause(): void;
+    resume(): void;
+}
+export interface TediousTypes {
+    NVarChar: TediousDataType;
+    BigInt: TediousDataType;
+    Int: TediousDataType;
+    Float: TediousDataType;
+    Bit: TediousDataType;
+    DateTime: TediousDataType;
+    VarBinary: TediousDataType;
+    [x: string]: TediousDataType;
+}
+export interface TediousDataType {
 }
 export interface TediousColumnValue {
     metadata: {

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

@@ -44,6 +44,7 @@ declare class MssqlConnection implements DatabaseConnection {
     constructor(connection: TediousConnection, tedious: Tedious);
     beginTransaction(settings: TransactionSettings): Promise<void>;
     commitTransaction(): Promise<void>;
+    connect(): Promise<this>;
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
     rollbackTransaction(): Promise<void>;
     streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;

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

@@ -15,13 +15,7 @@ export class MssqlDriver {
             ...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);
+                return await new MssqlConnection(connection, this.#config.tedious).connect();
             },
             destroy: async (connection) => {
                 await connection[PRIVATE_DESTROY_METHOD]();
@@ -60,6 +54,10 @@ class MssqlConnection {
     constructor(connection, tedious) {
         this.#connection = connection;
         this.#tedious = tedious;
+        this.#connection.on('error', console.error);
+        this.#connection.once('end', () => {
+            this.#connection.off('error', console.error);
+        });
     }
     async beginTransaction(settings) {
         const { isolationLevel } = settings;
@@ -80,10 +78,28 @@ class MssqlConnection {
                 resolve(undefined);
         }));
     }
+    async connect() {
+        await new Promise((resolve, reject) => {
+            this.#connection.connect((error) => {
+                if (error) {
+                    console.error(error);
+                    reject(error);
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+        });
+        return this;
+    }
     async executeQuery(compiledQuery) {
         try {
             const deferred = new Deferred();
-            const request = new MssqlRequest(this.#tedious, compiledQuery, deferred);
+            const request = new MssqlRequest({
+                compiledQuery,
+                tedious: this.#tedious,
+                onDone: deferred,
+            });
             this.#connection.execSql(request.request);
             const { rowCount, rows } = await deferred.promise;
             return {
@@ -107,11 +123,15 @@ class MssqlConnection {
         if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
             throw new Error('chunkSize must be a positive integer');
         }
-        const request = new MssqlRequest(this.#tedious, compiledQuery);
+        const request = new MssqlRequest({
+            compiledQuery,
+            streamChunkSize: chunkSize,
+            tedious: this.#tedious,
+        });
         this.#connection.execSql(request.request);
         try {
             while (true) {
-                const rows = await request.readChunk(chunkSize);
+                const rows = await request.readChunk();
                 if (rows.length === 0) {
                     break;
                 }
@@ -122,13 +142,17 @@ class MssqlConnection {
             }
         }
         finally {
-            this.#connection.cancel();
+            await this.#cancelRequest(request);
         }
     }
     async validate() {
         try {
             const deferred = new Deferred();
-            const request = new MssqlRequest(this.#tedious, CompiledQuery.raw('select 1'), deferred);
+            const request = new MssqlRequest({
+                compiledQuery: CompiledQuery.raw('select 1'),
+                onDone: deferred,
+                tedious: this.#tedious,
+            });
             this.#connection.execSql(request.request);
             await deferred.promise;
             return true;
@@ -152,6 +176,16 @@ class MssqlConnection {
         }
         return tediousIsolationLevel;
     }
+    #cancelRequest(request) {
+        return new Promise((resolve) => {
+            request.request.once('requestCompleted', resolve);
+            const wasCanceled = this.#connection.cancel();
+            if (!wasCanceled) {
+                request.request.off('requestCompleted', resolve);
+                resolve(undefined);
+            }
+        });
+    }
     [PRIVATE_RELEASE_METHOD]() {
         return new Promise((resolve, reject) => {
             this.#connection.reset((error) => {
@@ -174,42 +208,62 @@ class MssqlConnection {
 class MssqlRequest {
     #request;
     #rows;
+    #streamChunkSize;
+    #subscribers;
     #tedious;
-    #completed;
     #error;
     #rowCount;
-    constructor(tedious, compiledQuery, onDone) {
-        this.#completed = false;
+    constructor(props) {
+        const { compiledQuery, onDone, streamChunkSize, tedious } = props;
         this.#rows = [];
+        this.#streamChunkSize = streamChunkSize;
+        this.#subscribers = {};
         this.#tedious = tedious;
-        const { parameters, sql } = compiledQuery;
-        this.#request = new this.#tedious.Request(sql, (err, rowCount) => {
+        if (onDone) {
+            const subscriptionKey = 'onDone';
+            this.#subscribers[subscriptionKey] = (event, error) => {
+                if (event === 'chunkReady') {
+                    return;
+                }
+                delete this.#subscribers[subscriptionKey];
+                if (event === 'error') {
+                    onDone.reject(error);
+                }
+                else {
+                    onDone.resolve({
+                        rowCount: this.#rowCount,
+                        rows: this.#rows,
+                    });
+                }
+            };
+        }
+        this.#request = new this.#tedious.Request(compiledQuery.sql, (err, rowCount) => {
             if (err) {
-                this.#error = err instanceof AggregateError ? err.errors : err;
-                onDone?.reject(this.#error);
+                Object.values(this.#subscribers).forEach((subscriber) => subscriber('error', err instanceof AggregateError ? err.errors : err));
             }
             else {
                 this.#rowCount = rowCount;
             }
         });
-        this.#addParametersToRequest(parameters);
-        this.#attachListeners(onDone);
+        this.#addParametersToRequest(compiledQuery.parameters);
+        this.#attachListeners();
     }
     get request() {
         return this.#request;
     }
-    readChunk(chunkSize) {
+    readChunk() {
+        const subscriptionKey = this.readChunk.name;
         return new Promise((resolve, reject) => {
-            const interval = setInterval(() => {
-                if (this.#error) {
-                    clearInterval(interval);
-                    reject(this.#error);
+            this.#subscribers[subscriptionKey] = (event, error) => {
+                delete this.#subscribers[subscriptionKey];
+                if (event === 'error') {
+                    reject(error);
                 }
-                else if (this.#completed || this.#rows.length >= chunkSize) {
-                    clearInterval(interval);
-                    resolve(this.#rows.splice(0, chunkSize));
+                else {
+                    resolve(this.#rows.splice(0, this.#streamChunkSize));
                 }
-            }, 0);
+            };
+            this.#request.resume();
         });
     }
     #addParametersToRequest(parameters) {
@@ -218,22 +272,27 @@ class MssqlRequest {
             this.#request.addParameter(String(i + 1), this.#getTediousDataType(parameter), parameter);
         }
     }
-    #attachListeners(onDone) {
+    #attachListeners() {
+        const pauseAndEmitChunkReady = this.#streamChunkSize
+            ? () => {
+                if (this.#streamChunkSize <= this.#rows.length) {
+                    this.#request.pause();
+                    Object.values(this.#subscribers).forEach((subscriber) => subscriber('chunkReady'));
+                }
+            }
+            : () => { };
         const rowListener = (columns) => {
             const row = {};
             for (const column of columns) {
                 row[column.metadata.colName] = column.value;
             }
             this.#rows.push(row);
+            pauseAndEmitChunkReady();
         };
         this.#request.on('row', rowListener);
         this.#request.once('requestCompleted', () => {
-            this.#completed = true;
+            Object.values(this.#subscribers).forEach((subscriber) => subscriber('completed'));
             this.#request.off('row', rowListener);
-            onDone?.resolve({
-                rowCount: this.#rowCount,
-                rows: this.#rows,
-            });
         });
     }
     #getTediousDataType(value) {

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

@@ -14,8 +14,12 @@ export class MssqlIntrospector {
             .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')
+            .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
             .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
+            .leftJoin('sys.extended_properties as comments', (join) => join
+            .onRef('comments.major_id', '=', 'tables.object_id')
+            .onRef('comments.minor_id', '=', 'columns.column_id')
+            .on('comments.name', '=', 'MS_Description'))
             .$if(!options.withInternalKyselyTables, (qb) => qb
             .where('tables.name', '!=', DEFAULT_MIGRATION_TABLE)
             .where('tables.name', '!=', DEFAULT_MIGRATION_LOCK_TABLE))
@@ -36,13 +40,18 @@ export class MssqlIntrospector {
             'types.is_nullable as type_is_nullable',
             'types.name as type_name',
             'type_schemas.name as type_schema_name',
+            'comments.value as column_comment',
         ])
             .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')
+            .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
             .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
+            .leftJoin('sys.extended_properties as comments', (join) => join
+            .onRef('comments.major_id', '=', 'views.object_id')
+            .onRef('comments.minor_id', '=', 'columns.column_id')
+            .on('comments.name', '=', 'MS_Description'))
             .select([
             'views.name as table_name',
             'views.type as table_type',
@@ -57,6 +66,7 @@ export class MssqlIntrospector {
             'types.is_nullable as type_is_nullable',
             'types.name as type_name',
             'type_schemas.name as type_schema_name',
+            'comments.value as column_comment',
         ]))
             .orderBy('table_schema_name')
             .orderBy('table_name')
@@ -84,6 +94,7 @@ export class MssqlIntrospector {
                 isAutoIncrementing: rawColumn.column_is_identity,
                 isNullable: rawColumn.column_is_nullable && rawColumn.type_is_nullable,
                 name: rawColumn.column_name,
+                comment: rawColumn.column_comment ?? undefined,
             }));
         }
         return Object.values(tableDictionary);

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

@@ -1,11 +1,15 @@
 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 { OffsetNode } from '../../operation-node/offset-node.js';
+import { MergeQueryNode } from '../../operation-node/merge-query-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MssqlQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
+    protected visitOffset(node: OffsetNode): void;
     protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
     protected visitAddColumn(node: AddColumnNode): void;
     protected visitDropColumn(node: DropColumnNode): void;
+    protected visitMergeQuery(node: MergeQueryNode): void;
     protected announcesNewColumnDataType(): boolean;
 }

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

@@ -4,6 +4,10 @@ export class MssqlQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return `@${this.numParameters}`;
     }
+    visitOffset(node) {
+        super.visitOffset(node);
+        this.append(' rows');
+    }
     // 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
@@ -55,6 +59,10 @@ export class MssqlQueryCompiler extends DefaultQueryCompiler {
     visitDropColumn(node) {
         this.visitNode(node.column);
     }
+    visitMergeQuery(node) {
+        super.visitMergeQuery(node);
+        this.append(';');
+    }
     announcesNewColumnDataType() {
         return false;
     }

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

@@ -31,6 +31,7 @@ export class MysqlIntrospector {
             'columns.IS_NULLABLE',
             'columns.DATA_TYPE',
             'columns.EXTRA',
+            'columns.COLUMN_COMMENT',
         ])
             .where('columns.TABLE_SCHEMA', '=', sql `database()`)
             .orderBy('columns.TABLE_NAME')
@@ -67,6 +68,7 @@ export class MysqlIntrospector {
                 isNullable: it.IS_NULLABLE === 'YES',
                 isAutoIncrementing: it.EXTRA.toLowerCase().includes('auto_increment'),
                 hasDefaultValue: it.COLUMN_DEFAULT !== null,
+                comment: it.COLUMN_COMMENT === '' ? undefined : it.COLUMN_COMMENT,
             }));
             return tables;
         }, []);

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

@@ -52,7 +52,7 @@ export interface PostgresCursor<T> {
 }
 export type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
 export interface PostgresQueryResult<R> {
-    command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT';
+    command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT' | 'MERGE';
     rowCount: number;
     rows: R[];
 }

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

@@ -71,7 +71,8 @@ class PostgresConnection {
             ]);
             if (result.command === 'INSERT' ||
                 result.command === 'UPDATE' ||
-                result.command === 'DELETE') {
+                result.command === 'DELETE' ||
+                result.command === 'MERGE') {
                 const numAffectedRows = BigInt(result.rowCount);
                 return {
                     // TODO: remove.

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

@@ -36,6 +36,7 @@ export class PostgresIntrospector {
             'ns.nspname as schema',
             'typ.typname as type',
             'dtns.nspname as type_schema',
+            sql `col_description(a.attrelid, a.attnum)`.as('column_description'),
             // Detect if the column is auto incrementing by finding the sequence
             // that is created for `serial` and `bigserial` columns.
             this.#db
@@ -48,7 +49,7 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where((eb) => eb.or([eb('c.relkind', '=', 'r'), eb('c.relkind', '=', 'v')]))
+            .where((eb) => eb.or([eb('c.relkind', '=', 'r'), eb('c.relkind', '=', 'v'), eb('c.relkind', '=', 'p')]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns
@@ -90,6 +91,7 @@ export class PostgresIntrospector {
                 isNullable: !it.not_null,
                 isAutoIncrementing: !!it.auto_incrementing,
                 hasDefaultValue: it.has_default,
+                comment: it.column_description ?? undefined,
             }));
             return tables;
         }, []);

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

@@ -61,6 +61,7 @@ export class SqliteIntrospector {
                 isNullable: !col.notnull,
                 isAutoIncrementing: col.name === autoIncrementCol,
                 hasDefaultValue: col.dflt_value != null,
+                comment: undefined,
             })),
         };
     }

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

@@ -14,14 +14,16 @@ export interface QueryResult<O> {
      */
     readonly numUpdatedOrDeletedRows?: bigint;
     /**
-     * This is defined for insert, update and delete queries and contains
+     * 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 by some drivers like node-mysql2.
+     *
+     * This is **optional** and only provided in dialects such as MySQL.
+     * You would probably use {@link numAffectedRows} in most cases.
      */
     readonly numChangedRows?: bigint;
     /**

package/dist/esm/dynamic/dynamic.d.ts

@@ -5,7 +5,7 @@ export declare class DynamicModule {
      *
      * Kysely is built in a way that by default you can't refer to tables or columns
      * that are not actually visible in the current query and context. This is all
-     * done by typescript at compile time, which means that you need to know the
+     * done by TypeScript at compile time, which means that you need to know the
      * columns and tables at compile time. This is not always the case of course.
      *
      * This method is meant to be used in those cases where the column names

package/dist/esm/dynamic/dynamic.js

@@ -6,7 +6,7 @@ export class DynamicModule {
      *
      * Kysely is built in a way that by default you can't refer to tables or columns
      * that are not actually visible in the current query and context. This is all
-     * done by typescript at compile time, which means that you need to know the
+     * done by TypeScript at compile time, which means that you need to know the
      * columns and tables at compile time. This is not always the case of course.
      *
      * This method is meant to be used in those cases where the column names