kysely 0.28.17 → 0.29.0

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

@@ -1,115 +0,0 @@
-import type { Kysely } from '../kysely.js';
-/**
- * A `DialectAdapter` encapsulates all differences between dialects outside
- * of `Driver` and `QueryCompiler`.
- *
- * For example, some databases support transactional DDL and therefore we want
- * to run migrations inside a transaction, while other databases don't support
- * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
- */
-export interface DialectAdapter {
-    /**
-     * Whether or not this dialect supports `if not exists` in creation of tables/schemas/views/etc.
-     *
-     * If this is false, Kysely's internal migrations tables and schemas are created
-     * without `if not exists` in migrations. This is not a problem if the dialect
-     * supports transactional DDL.
-     */
-    readonly supportsCreateIfNotExists: boolean;
-    /**
-     * Whether or not this dialect supports transactional DDL.
-     *
-     * If this is true, migrations are executed inside a transaction.
-     */
-    readonly supportsTransactionalDdl: boolean;
-    /**
-     * Whether or not this dialect supports the `returning` in inserts
-     * 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.
-     *
-     * 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>, options: 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>, options: MigrationLockOptions): Promise<void>;
-}
-export interface MigrationLockOptions {
-    /**
-     * The name of the migration lock table.
-     */
-    readonly lockTable: string;
-    /**
-     * The id of the only row in the migration lock table.
-     */
-    readonly lockRowId: string;
-    /**
-     * The schema in which the migration lock table lives. This is only
-     * defined if the user has specified a custom schema in the migration
-     * settings.
-     */
-    readonly lockTableSchema?: string;
-}

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

@@ -1,34 +0,0 @@
-import type { Driver } from '../driver/driver.js';
-import type { Kysely } from '../kysely.js';
-import type { QueryCompiler } from '../query-compiler/query-compiler.js';
-import type { DatabaseIntrospector } from './database-introspector.js';
-import type { DialectAdapter } from './dialect-adapter.js';
-/**
- * A Dialect is the glue between Kysely and the underlying database engine.
- *
- * See the built-in {@link PostgresDialect} as an example of a dialect.
- * Users can implement their own dialects and use them by passing it
- * in the {@link KyselyConfig.dialect} property.
- */
-export interface Dialect {
-    /**
-     * Creates a driver for the dialect.
-     */
-    createDriver(): Driver;
-    /**
-     * Creates a query compiler for the dialect.
-     */
-    createQueryCompiler(): QueryCompiler;
-    /**
-     * Creates an adapter for the dialect.
-     */
-    createAdapter(): DialectAdapter;
-    /**
-     * Creates a database introspector that can be used to get database metadata
-     * such as the table names and column names of those tables.
-     *
-     * `db` never has any plugins installed. It's created using
-     * {@link Kysely.withoutPlugins}.
-     */
-    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
-}

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

@@ -1,83 +0,0 @@
-import type { Kysely } from '../../kysely.js';
-import { DialectAdapterBase } from '../dialect-adapter-base.js';
-export declare class MssqlAdapter extends DialectAdapterBase {
-    /**
-     * Whether or not this dialect supports `if not exists` in creation of tables/schemas/views/etc.
-     *
-     * If this is false, Kysely's internal migrations tables and schemas are created
-     * without `if not exists` in migrations. This is not a problem if the dialect
-     * supports transactional DDL.
-     */
-    get supportsCreateIfNotExists(): boolean;
-    /**
-     * Whether or not this dialect supports transactional DDL.
-     *
-     * If this is true, migrations are executed inside a transaction.
-     */
-    get supportsTransactionalDdl(): 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.
-     *
-     * 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>): 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(): Promise<void>;
-}

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

@@ -1,181 +0,0 @@
-import type { KyselyTypeError } from '../../util/type-error.js';
-export interface MssqlDialectConfig {
-    /**
-     * When `true`, connections are reset to their initial states when released
-     * back to the pool, resulting in additional requests to the database.
-     *
-     * Defaults to `false`.
-     */
-    resetConnectionsOnRelease?: boolean;
-    /**
-     * This dialect uses the `tarn` package to manage the connection pool to your
-     * database. To use it as a peer dependency and not bundle it with Kysely's code,
-     * you need to pass the `tarn` package itself. You also need to pass some pool options
-     * (excluding `create`, `destroy` and `validate` functions which are controlled by this dialect),
-     * `min` & `max` connections at the very least.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { MssqlDialect } from 'kysely'
-     * import * as Tarn from 'tarn'
-     * import * as Tedious from 'tedious'
-     *
-     * const dialect = new MssqlDialect({
-     *   tarn: { ...Tarn, options: { max: 10, min: 0 } },
-     *   tedious: {
-     *     ...Tedious,
-     *     connectionFactory: () => new Tedious.Connection({
-     *       // ...
-     *       server: 'localhost',
-     *       // ...
-     *     }),
-     *   }
-     * })
-     * ```
-     */
-    tarn: Tarn;
-    /**
-     * This dialect uses the `tedious` package to communicate with your MS SQL Server
-     * database. To use it as a peer dependency and not bundle it with Kysely's code,
-     * you need to pass the `tedious` package itself. You also need to pass a factory
-     * function that creates new `tedious` `Connection` instances on demand.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { MssqlDialect } from 'kysely'
-     * import * as Tarn from 'tarn'
-     * import * as Tedious from 'tedious'
-     *
-     * const dialect = new MssqlDialect({
-     *   tarn: { ...Tarn, options: { max: 10, min: 0 } },
-     *   tedious: {
-     *     ...Tedious,
-     *     connectionFactory: () => new Tedious.Connection({
-     *       // ...
-     *       server: 'localhost',
-     *       // ...
-     *     }),
-     *   }
-     * })
-     * ```
-     */
-    tedious: Tedious;
-    /**
-     * When `true`, connections are validated before being acquired from the pool,
-     * resulting in additional requests to the database.
-     *
-     * Defaults to `true`.
-     */
-    validateConnections?: boolean;
-}
-export interface Tedious {
-    connectionFactory: () => TediousConnection | Promise<TediousConnection>;
-    ISOLATION_LEVEL: TediousIsolationLevel;
-    Request: TediousRequestClass;
-    /**
-     * @deprecated use {@link MssqlDialectConfig.resetConnectionsOnRelease} instead.
-     */
-    resetConnectionOnRelease?: KyselyTypeError<'deprecated: use `MssqlDialectConfig.resetConnectionsOnRelease` instead'>;
-    TYPES: TediousTypes;
-}
-export interface TediousConnection {
-    beginTransaction(callback: (err: Error | null | undefined, transactionDescriptor?: any) => void, name?: string | undefined, isolationLevel?: number | undefined): void;
-    cancel(): boolean;
-    close(): void;
-    commitTransaction(callback: (err: Error | null | undefined) => void, name?: string | undefined): void;
-    connect(connectListener: (err?: Error) => void): void;
-    execSql(request: TediousRequest): 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: (err: Error | null | undefined) => void): void;
-    rollbackTransaction(callback: (err: Error | null | undefined) => void, name?: string | undefined): void;
-    saveTransaction(callback: (err: Error | null | undefined) => 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 {
-    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: {
-        colName: string;
-    };
-    value: any;
-}
-export interface Tarn {
-    /**
-     * Tarn.js' pool options, excluding `create`, `destroy` and `validate` functions,
-     * which must be implemented by this dialect.
-     */
-    options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'> & {
-        /**
-         * @deprecated use {@link MssqlDialectConfig.validateConnections} instead.
-         */
-        validateConnections?: KyselyTypeError<'deprecated: use `MssqlDialectConfig.validateConnections` instead'>;
-    };
-    /**
-     * Tarn.js' Pool class.
-     */
-    Pool: typeof TarnPool;
-}
-export declare class TarnPool<R> {
-    constructor(opt: TarnPoolOptions<R>);
-    acquire(): TarnPendingRequest<R>;
-    destroy(): any;
-    release(resource: R): void;
-}
-export interface TarnPoolOptions<R> {
-    acquireTimeoutMillis?: number;
-    create(cb: (err: Error | null, resource: R) => void): any | (() => Promise<R>);
-    createRetryIntervalMillis?: number;
-    createTimeoutMillis?: number;
-    destroy(resource: R): any;
-    destroyTimeoutMillis?: number;
-    idleTimeoutMillis?: number;
-    log?(msg: string): any;
-    max: number;
-    min: number;
-    propagateCreateError?: boolean;
-    reapIntervalMillis?: number;
-    validate?(resource: R): boolean;
-}
-export interface TarnPendingRequest<R> {
-    promise: Promise<R>;
-    resolve: (resource: R) => void;
-    reject: (err: Error) => void;
-}

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

@@ -1,70 +0,0 @@
-import type { Driver } from '../../driver/driver.js';
-import type { Kysely } from '../../kysely.js';
-import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
-import type { DatabaseIntrospector } from '../database-introspector.js';
-import type { DialectAdapter } from '../dialect-adapter.js';
-import type { Dialect } from '../dialect.js';
-import type { MssqlDialectConfig } from './mssql-dialect-config.js';
-/**
- * MS SQL Server dialect that uses the [tedious](https://tediousjs.github.io/tedious)
- * library.
- *
- * The constructor takes an instance of {@link MssqlDialectConfig}.
- *
- * ```ts
- * import * as Tedious from 'tedious'
- * import * as Tarn from 'tarn'
- *
- * const dialect = new MssqlDialect({
- *   tarn: {
- *     ...Tarn,
- *     options: {
- *       min: 0,
- *       max: 10,
- *     },
- *   },
- *   tedious: {
- *     ...Tedious,
- *     connectionFactory: () => new Tedious.Connection({
- *       authentication: {
- *         options: {
- *           password: 'password',
- *           userName: 'username',
- *         },
- *         type: 'default',
- *       },
- *       options: {
- *         database: 'some_db',
- *         port: 1433,
- *         trustServerCertificate: true,
- *       },
- *       server: 'localhost',
- *     }),
- *   },
- * })
- * ```
- */
-export declare class MssqlDialect implements Dialect {
-    #private;
-    constructor(config: MssqlDialectConfig);
-    /**
-     * Creates a driver for the dialect.
-     */
-    createDriver(): Driver;
-    /**
-     * Creates a query compiler for the dialect.
-     */
-    createQueryCompiler(): QueryCompiler;
-    /**
-     * Creates an adapter for the dialect.
-     */
-    createAdapter(): DialectAdapter;
-    /**
-     * Creates a database introspector that can be used to get database metadata
-     * such as the table names and column names of those tables.
-     *
-     * `db` never has any plugins installed. It's created using
-     * {@link Kysely.withoutPlugins}.
-     */
-    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
-}

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

@@ -1,59 +0,0 @@
-import type { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
-import type { Driver, TransactionSettings } from '../../driver/driver.js';
-import type { MssqlDialectConfig, Tedious, TediousConnection } from './mssql-dialect-config.js';
-import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-declare const PRIVATE_RESET_METHOD: unique symbol;
-declare const PRIVATE_DESTROY_METHOD: unique symbol;
-declare const PRIVATE_VALIDATE_METHOD: unique symbol;
-export declare class MssqlDriver implements Driver {
-    #private;
-    constructor(config: MssqlDialectConfig);
-    /**
-     * 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: MssqlConnection, settings: TransactionSettings): Promise<void>;
-    /**
-     * Commits a transaction.
-     */
-    commitTransaction(connection: MssqlConnection): Promise<void>;
-    /**
-     * Rolls back a transaction.
-     */
-    rollbackTransaction(connection: MssqlConnection): Promise<void>;
-    savepoint(connection: MssqlConnection, savepointName: string): Promise<void>;
-    rollbackToSavepoint(connection: MssqlConnection, savepointName: string): Promise<void>;
-    /**
-     * Releases a connection back to the pool.
-     */
-    releaseConnection(connection: MssqlConnection): Promise<void>;
-    /**
-     * Destroys the driver and releases all resources.
-     */
-    destroy(): Promise<void>;
-}
-declare class MssqlConnection implements DatabaseConnection {
-    #private;
-    constructor(connection: TediousConnection, tedious: Tedious);
-    beginTransaction(settings: TransactionSettings): Promise<void>;
-    commitTransaction(): Promise<void>;
-    connect(): Promise<this>;
-    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
-    rollbackTransaction(savepointName?: string): Promise<void>;
-    savepoint(savepointName: string): Promise<void>;
-    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
-    [PRIVATE_DESTROY_METHOD](): Promise<void>;
-    [PRIVATE_RESET_METHOD](): Promise<void>;
-    [PRIVATE_VALIDATE_METHOD](): Promise<boolean>;
-}
-export {};