kysely 0.27.3 → 0.27.5

package/dist/cjs/util/object-utils.js

@@ -1,6 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isPlainObject = exports.isArrayBufferOrView = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isUndefined = exports.isEmpty = void 0;
+exports.isEmpty = isEmpty;
+exports.isUndefined = isUndefined;
+exports.isString = isString;
+exports.isNumber = isNumber;
+exports.isBoolean = isBoolean;
+exports.isNull = isNull;
+exports.isDate = isDate;
+exports.isBigInt = isBigInt;
+exports.isBuffer = isBuffer;
+exports.isFunction = isFunction;
+exports.isObject = isObject;
+exports.isArrayBufferOrView = isArrayBufferOrView;
+exports.isPlainObject = isPlainObject;
+exports.getLast = getLast;
+exports.freeze = freeze;
+exports.asArray = asArray;
+exports.asReadonlyArray = asReadonlyArray;
+exports.isReadonlyArray = isReadonlyArray;
+exports.noop = noop;
+exports.compare = compare;
 function isEmpty(obj) {
     if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
@@ -10,69 +29,60 @@ function isEmpty(obj) {
     }
     return false;
 }
-exports.isEmpty = isEmpty;
 function isUndefined(obj) {
     return typeof obj === 'undefined' || obj === undefined;
 }
-exports.isUndefined = isUndefined;
 function isString(obj) {
     return typeof obj === 'string';
 }
-exports.isString = isString;
 function isNumber(obj) {
     return typeof obj === 'number';
 }
-exports.isNumber = isNumber;
 function isBoolean(obj) {
     return typeof obj === 'boolean';
 }
-exports.isBoolean = isBoolean;
 function isNull(obj) {
     return obj === null;
 }
-exports.isNull = isNull;
 function isDate(obj) {
     return obj instanceof Date;
 }
-exports.isDate = isDate;
 function isBigInt(obj) {
     return typeof obj === 'bigint';
 }
-exports.isBigInt = isBigInt;
 // Don't change the returnd type to `obj is Buffer` to not create a
 // hard dependency to node.
 function isBuffer(obj) {
     return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
 }
-exports.isBuffer = isBuffer;
 function isFunction(obj) {
     return typeof obj === 'function';
 }
-exports.isFunction = isFunction;
 function isObject(obj) {
     return typeof obj === 'object' && obj !== null;
 }
-exports.isObject = isObject;
 function isArrayBufferOrView(obj) {
     return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
 }
-exports.isArrayBufferOrView = isArrayBufferOrView;
 function isPlainObject(obj) {
-    return (isObject(obj) &&
-        !Array.isArray(obj) &&
-        !isDate(obj) &&
-        !isBuffer(obj) &&
-        !isArrayBufferOrView(obj));
+    if (!isObject(obj) || getTag(obj) !== '[object Object]') {
+        return false;
+    }
+    if (Object.getPrototypeOf(obj) === null) {
+        return true;
+    }
+    let proto = obj;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(obj) === proto;
 }
-exports.isPlainObject = isPlainObject;
 function getLast(arr) {
     return arr[arr.length - 1];
 }
-exports.getLast = getLast;
 function freeze(obj) {
     return Object.freeze(obj);
 }
-exports.freeze = freeze;
 function asArray(arg) {
     if (isReadonlyArray(arg)) {
         return arg;
@@ -81,7 +91,6 @@ function asArray(arg) {
         return [arg];
     }
 }
-exports.asArray = asArray;
 function asReadonlyArray(arg) {
     if (isReadonlyArray(arg)) {
         return arg;
@@ -90,15 +99,12 @@ function asReadonlyArray(arg) {
         return freeze([arg]);
     }
 }
-exports.asReadonlyArray = asReadonlyArray;
 function isReadonlyArray(arg) {
     return Array.isArray(arg);
 }
-exports.isReadonlyArray = isReadonlyArray;
 function noop(obj) {
     return obj;
 }
-exports.noop = noop;
 function compare(obj1, obj2) {
     if (isReadonlyArray(obj1) && isReadonlyArray(obj2)) {
         return compareArrays(obj1, obj2);
@@ -108,7 +114,6 @@ function compare(obj1, obj2) {
     }
     return obj1 === obj2;
 }
-exports.compare = compare;
 function compareArrays(arr1, arr2) {
     if (arr1.length !== arr2.length) {
         return false;
@@ -148,3 +153,10 @@ function compareGenericObjects(obj1, obj2) {
     }
     return true;
 }
+const toString = Object.prototype.toString;
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return toString.call(value);
+}

package/dist/cjs/util/performance-now.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performanceNow = void 0;
+exports.performanceNow = performanceNow;
 const object_utils_js_1 = require("./object-utils.js");
 function performanceNow() {
     if (typeof performance !== 'undefined' && (0, object_utils_js_1.isFunction)(performance.now)) {
@@ -10,4 +10,3 @@ function performanceNow() {
         return Date.now();
     }
 }
-exports.performanceNow = performanceNow;

package/dist/cjs/util/prevent-await.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.preventAwait = void 0;
+exports.preventAwait = preventAwait;
 function preventAwait(clazz, message) {
     Object.defineProperties(clazz.prototype, {
         then: {
@@ -11,4 +11,3 @@ function preventAwait(clazz, message) {
         },
     });
 }
-exports.preventAwait = preventAwait;

package/dist/cjs/util/query-id.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createQueryId = void 0;
+exports.createQueryId = createQueryId;
 const random_string_js_1 = require("./random-string.js");
 function createQueryId() {
     return new LazyQueryId();
 }
-exports.createQueryId = createQueryId;
 class LazyQueryId {
     #queryId;
     get queryId() {

package/dist/cjs/util/random-string.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomString = void 0;
+exports.randomString = randomString;
 const CHARS = [
     'A',
     'B',
@@ -72,7 +72,6 @@ function randomString(length) {
     }
     return chars;
 }
-exports.randomString = randomString;
 function randomChar() {
     return CHARS[~~(Math.random() * CHARS.length)];
 }

package/dist/cjs/util/require-all-props.d.ts

@@ -26,14 +26,16 @@ type AllProps<T> = T & {
  * 1. Omit checked type - all checked properties will be expect as of type never
  *
  * ```ts
- * const z: SomeType = requireAllProps({ propC: "no type will work" });
+ * type SomeType = { propA: string; propB?: number; }
+ * // const z: SomeType = requireAllProps({ propC: "no type will work" }); // Property 'propA' is missing in type '{ propC: string; }' but required in type 'SomeType'.
  * ```
  *
  * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
  *
  * ```ts
+ * type SomeType = { propA: string; propB?: number; }
  * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
- * const x = requireAllProps<SomeType>( { ... y } );
+ * // const x = requireAllProps<SomeType>({ ...y }); // Argument of type '{ propA: string; propB?: number; }' is not assignable to parameter of type 'AllProps<SomeType>'.
  * ```
  *
  * @param obj object to check if all properties has been used

package/dist/cjs/util/require-all-props.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireAllProps = void 0;
+exports.requireAllProps = requireAllProps;
 /**
  * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
  *
@@ -21,14 +21,16 @@ exports.requireAllProps = void 0;
  * 1. Omit checked type - all checked properties will be expect as of type never
  *
  * ```ts
- * const z: SomeType = requireAllProps({ propC: "no type will work" });
+ * type SomeType = { propA: string; propB?: number; }
+ * // const z: SomeType = requireAllProps({ propC: "no type will work" }); // Property 'propA' is missing in type '{ propC: string; }' but required in type 'SomeType'.
  * ```
  *
  * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
  *
  * ```ts
+ * type SomeType = { propA: string; propB?: number; }
  * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
- * const x = requireAllProps<SomeType>( { ... y } );
+ * // const x = requireAllProps<SomeType>({ ...y }); // Argument of type '{ propA: string; propB?: number; }' is not assignable to parameter of type 'AllProps<SomeType>'.
  * ```
  *
  * @param obj object to check if all properties has been used
@@ -37,4 +39,3 @@ exports.requireAllProps = void 0;
 function requireAllProps(obj) {
     return obj;
 }
-exports.requireAllProps = requireAllProps;

package/dist/cjs/util/stack-trace-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendStackTrace = void 0;
+exports.extendStackTrace = extendStackTrace;
 const object_utils_js_1 = require("./object-utils.js");
 function extendStackTrace(err, stackError) {
     if (isStackHolder(err) && stackError.stack) {
@@ -11,7 +11,6 @@ function extendStackTrace(err, stackError) {
     }
     return err;
 }
-exports.extendStackTrace = extendStackTrace;
 function isStackHolder(obj) {
     return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isString)(obj.stack);
 }

package/dist/cjs/util/streamable.d.ts

@@ -8,7 +8,7 @@ export interface Streamable<O> {
      * ### Examples
      *
      * ```ts
-     * const stream = db.
+     * const stream = db
      *   .selectFrom('person')
      *   .select(['first_name', 'last_name'])
      *   .where('gender', '=', 'other')

package/dist/cjs/util/type-utils.d.ts

@@ -125,7 +125,9 @@ export type NarrowPartial<O, T> = DrainOuterGeneric<T extends object ? {
  * Example:
  *
  * ```ts
- * const person = await db.selectFrom('person')
+ * import type { NotNull } from 'kysely'
+ *
+ * await db.selectFrom('person')
  *   .where('nullable_column', 'is not', null)
  *   .selectAll()
  *   .$narrowType<{ nullable_column: NotNull }>()
@@ -148,7 +150,7 @@ export type SqlBool = boolean | 0 | 1;
  *   A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
  * >
  *
- * type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
+ * // type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
  * ```
  *
  * To fix this, we can use `DrainOuterGeneric`:

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.
@@ -46,8 +47,13 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * 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
@@ -63,6 +69,10 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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.
@@ -47,8 +52,13 @@ export interface DialectAdapter {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * 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
@@ -64,6 +74,10 @@ export interface DialectAdapter {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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.
@@ -40,8 +36,13 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * 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
@@ -57,6 +58,10 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -6,21 +6,23 @@ export interface MssqlDialectConfig {
      * (excluding `create`, `destroy` and `validate` functions which are controlled by this dialect),
      * `min` & `max` connections at the very least.
      *
-     * Example:
+     * ### Examples
      *
      * ```ts
+     * import { MssqlDialect } from 'kysely'
      * import * as Tarn from 'tarn'
+     * import * as Tedious from 'tedious'
      *
      * const dialect = new MssqlDialect({
-     *   // ...
-     *   tarn: {
-     *     ...Tarn,
-     *     options: {
+     *   tarn: { ...Tarn, options: { max: 10, min: 0 } },
+     *   tedious: {
+     *     ...Tedious,
+     *     connectionFactory: () => new Tedious.Connection({
      *       // ...
-     *       min: 0,
-     *       max: 10,
-     *     },
-     *   },
+     *       server: 'localhost',
+     *       // ...
+     *     }),
+     *   }
      * })
      * ```
      */
@@ -31,17 +33,23 @@ export interface MssqlDialectConfig {
      * you need to pass the `tedious` package itself. You also need to pass a factory
      * function that creates new `tedious` `Connection` instances on demand.
      *
-     * Example:
+     * ### 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({ ... }),
-     *   },
+     *     connectionFactory: () => new Tedious.Connection({
+     *       // ...
+     *       server: 'localhost',
+     *       // ...
+     *     }),
+     *   }
      * })
      * ```
      */
@@ -50,39 +58,66 @@ 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;
+    /**
+     * Controls whether connections are reset to their initial states when released back to the pool. Resetting a connection performs additional requests to the database.
+     * See {@link https://tediousjs.github.io/tedious/api-connection.html#function_reset | connection.reset}.
+     *
+     * Defaults to `true`.
+     */
+    resetConnectionOnRelease?: boolean;
 }
 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: {
@@ -95,23 +130,16 @@ 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'>;
+    options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'> & {
+        /**
+         * Controls whether connections are validated before being acquired from the pool. Connection validation performs additional requests to the database.
+         *
+         * Defaults to `true`.
+         */
+        validateConnections?: boolean;
+    };
     /**
      * Tarn.js' Pool class.
-     *
-     * Example:
-     *
-     * ```ts
-     * import { Pool } from 'tarn'
-     *
-     * const dialect = new MssqlDialect({
-     *   // ...
-     *   tarn: {
-     *     // ...
-     *     Pool,
-     *   },
-     * })
-     * ```
      */
     Pool: typeof TarnPool;
 }
@@ -134,7 +162,7 @@ export interface TarnPoolOptions<R> {
     min: number;
     propagateCreateError?: boolean;
     reapIntervalMillis?: number;
-    validate(resource: R): boolean;
+    validate?(resource: R): boolean;
 }
 export interface TarnPendingRequest<R> {
     promise: Promise<R>;

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>>;