kysely 0.27.4 → 0.27.6

package/dist/cjs/schema/create-table-builder.js

@@ -75,7 +75,7 @@ class CreateTableBuilder {
      *
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
+     *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
@@ -83,7 +83,7 @@ class CreateTableBuilder {
      *   // don't include it.
      *   .addColumn('data', sql`any_type_here`)
      *   .addColumn('parent_id', 'integer', (col) =>
-     *     col.references('person.id').onDelete('cascade'))
+     *     col.references('person.id').onDelete('cascade')
      *   )
      * ```
      *
@@ -94,11 +94,18 @@ class CreateTableBuilder {
      * `create table` query. See the next example:
      *
      * ```ts
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('id', 'integer', (col) => col.primaryKey())
      *   .addColumn('parent_id', 'integer')
      *   .addForeignKeyConstraint(
-     *     'person_parent_id_fk', ['parent_id'], 'person', ['id'],
+     *     'person_parent_id_fk',
+     *     ['parent_id'],
+     *     'person',
+     *     ['id'],
      *     (cb) => cb.onDelete('cascade')
      *   )
+     *   .execute()
      * ```
      *
      * Another good example is that PostgreSQL doesn't support the `auto_increment`
@@ -108,7 +115,8 @@ class CreateTableBuilder {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'serial', (col) => col.primaryKey()),
+     *   .addColumn('id', 'serial', (col) => col.primaryKey())
+     *   .execute()
      * ```
      */
     addColumn(columnName, dataType, build = object_utils_js_1.noop) {
@@ -127,7 +135,12 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('first_name', 'varchar(64)')
+     *   .addColumn('last_name', 'varchar(64)')
+     *   .addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
+     *   .execute()
      * ```
      */
     addPrimaryKeyConstraint(constraintName, columns) {
@@ -145,12 +158,30 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * addUniqueConstraint('first_name_last_name_unique', ['first_name', 'last_name'])
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('first_name', 'varchar(64)')
+     *   .addColumn('last_name', 'varchar(64)')
+     *   .addUniqueConstraint(
+     *     'first_name_last_name_unique',
+     *     ['first_name', 'last_name']
+     *   )
+     *   .execute()
      * ```
      *
      * In dialects such as PostgreSQL you can specify `nulls not distinct` as follows:
+     *
      * ```ts
-     * addUniqueConstraint('first_name_last_name_unique', ['first_name', 'last_name'], (builder) => builder.nullsNotDistinct())
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('first_name', 'varchar(64)')
+     *   .addColumn('last_name', 'varchar(64)')
+     *   .addUniqueConstraint(
+     *     'first_name_last_name_unique',
+     *     ['first_name', 'last_name'],
+     *     (cb) => cb.nullsNotDistinct()
+     *   )
+     *   .execute()
      * ```
      */
     addUniqueConstraint(constraintName, columns, build = object_utils_js_1.noop) {
@@ -171,7 +202,11 @@ class CreateTableBuilder {
      * ```ts
      * import { sql } from 'kysely'
      *
-     * addCheckConstraint('check_legs', sql`number_of_legs < 5`)
+     * await db.schema
+     *   .createTable('animal')
+     *   .addColumn('number_of_legs', 'integer')
+     *   .addCheckConstraint('check_legs', sql`number_of_legs < 5`)
+     *   .execute()
      * ```
      */
     addCheckConstraint(constraintName, checkExpression) {
@@ -189,24 +224,33 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * addForeignKeyConstraint(
-     *   'owner_id_foreign',
-     *   ['owner_id'],
-     *   'person',
-     *   ['id'],
-     * )
+     * await db.schema
+     *   .createTable('pet')
+     *   .addColumn('owner_id', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'owner_id_foreign',
+     *     ['owner_id'],
+     *     'person',
+     *     ['id'],
+     *   )
+     *   .execute()
      * ```
      *
      * Add constraint for multiple columns:
      *
      * ```ts
-     * addForeignKeyConstraint(
-     *   'owner_id_foreign',
-     *   ['owner_id1', 'owner_id2'],
-     *   'person',
-     *   ['id1', 'id2'],
-     *   (cb) => cb.onDelete('cascade')
-     * )
+     * await db.schema
+     *   .createTable('pet')
+     *   .addColumn('owner_id1', 'integer')
+     *   .addColumn('owner_id2', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'owner_id_foreign',
+     *     ['owner_id1', 'owner_id2'],
+     *     'person',
+     *     ['id1', 'id2'],
+     *     (cb) => cb.onDelete('cascade')
+     *   )
+     *   .execute()
      * ```
      */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = object_utils_js_1.noop) {
@@ -224,11 +268,14 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * db.schema.createTable('person')
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .createTable('person')
      *   .modifyFront(sql`global temporary`)
      *   .addColumn('id', 'integer', col => col.primaryKey())
      *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
-     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64)', col => col.notNull())
      *   .execute()
      * ```
      *
@@ -256,10 +303,13 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * db.schema.createTable('person')
-     *   .addColumn('id', 'integer', col => col => primaryKey())
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('id', 'integer', col => col.primaryKey())
      *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
-     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64)', col => col.notNull())
      *   .modifyEnd(sql`collate utf8_unicode_ci`)
      *   .execute()
      * ```
@@ -286,7 +336,8 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * db.schema.createTable('copy')
+     * await db.schema
+     *   .createTable('copy')
      *   .temporary()
      *   .as(db.selectFrom('person').select(['first_name', 'last_name']))
      *   .execute()
@@ -313,17 +364,19 @@ class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * db.schema
+     * await db.schema
      *   .createTable('test')
      *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
+     * This is useful for creating reusable functions that can be called with a builder.
+     *
      * ```ts
-     * const addDefaultColumns = <T extends string, C extends string = never>(
-     *   builder: CreateTableBuilder<T, C>
-     * ) => {
-     *   return builder
+     * import { type CreateTableBuilder, sql } from 'kysely'
+     *
+     * const addDefaultColumns = (ctb: CreateTableBuilder<any, any>) => {
+     *   return ctb
      *     .addColumn('id', 'integer', (col) => col.notNull())
      *     .addColumn('created_at', 'date', (col) =>
      *       col.notNull().defaultTo(sql`now()`)
@@ -333,7 +386,7 @@ class CreateTableBuilder {
      *     )
      * }
      *
-     * db.schema
+     * await db.schema
      *   .createTable('test')
      *   .$call(addDefaultColumns)
      *   .execute()

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

@@ -15,7 +15,7 @@ import { DrainOuterGeneric } from './type-utils.js';
  * type is actually just a shortcut for the type in this example:
  *
  * ```ts
- * ColumnType<number, number | undefined, number>
+ * type GeneratedNumber = ColumnType<number, number | undefined, number>
  * ```
  *
  * The above example makes the column optional in inserts
@@ -24,14 +24,14 @@ import { DrainOuterGeneric } from './type-utils.js';
  * can se the type as `never`:
  *
  * ```ts
- * ColumnType<number, never, never>
+ * type ReadonlyNumber = ColumnType<number, never, never>
  * ```
  *
  * Here's one more example where the type is different
  * for each different operation:
  *
  * ```ts
- * ColumnType<Date, string, never>
+ * type UnupdateableDate = ColumnType<Date, string, never>
  * ```
  */
 export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
@@ -44,12 +44,8 @@ export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectT
  * is the same for all selects, inserts and updates but the
  * column is optional for inserts and updates.
  *
- * The implementation:
- *
- * ```ts
- * // The update type is `S` instead of `S | undefined` because
- * // updates are always optional --> no need to specify optionality.
- * type Generated<S> = ColumnType<S, S | undefined, S>
+ * The update type is `S` instead of `S | undefined` because updates are always
+ * optional --> no need to specify optionality.
  * ```
  */
 export type Generated<S> = ColumnType<S, S | undefined, S>;

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

@@ -21,14 +21,16 @@ exports.requireAllProps = requireAllProps;
  * 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/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

@@ -47,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
@@ -64,6 +69,10 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -52,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
@@ -69,6 +74,10 @@ export interface DialectAdapter {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -36,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
@@ -53,6 +58,10 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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',
+     *       // ...
+     *     }),
+     *   }
      * })
      * ```
      */
@@ -52,6 +60,13 @@ export interface Tedious {
     ISOLATION_LEVEL: TediousIsolationLevel;
     Request: TediousRequestClass;
     TYPES: TediousTypes;
+    /**
+     * 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 | null, transactionDescriptor?: any) => void, name?: string, isolationLevel?: number): void;
@@ -115,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;
 }
@@ -154,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.js

@@ -11,18 +11,22 @@ export class MssqlDriver {
     #pool;
     constructor(config) {
         this.#config = freeze({ ...config });
-        this.#pool = new this.#config.tarn.Pool({
-            ...this.#config.tarn.options,
+        const { tarn, tedious } = this.#config;
+        const { validateConnections, ...poolOptions } = tarn.options;
+        this.#pool = new tarn.Pool({
+            ...poolOptions,
             create: async () => {
-                const connection = await this.#config.tedious.connectionFactory();
-                return await new MssqlConnection(connection, this.#config.tedious).connect();
+                const connection = await tedious.connectionFactory();
+                return await new MssqlConnection(connection, tedious).connect();
             },
             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(),
+            validate: validateConnections === false
+                ? undefined
+                : (connection) => connection.validate(),
         });
     }
     async init() {
@@ -186,15 +190,18 @@ class MssqlConnection {
             }
         });
     }
-    [PRIVATE_RELEASE_METHOD]() {
-        return new Promise((resolve, reject) => {
-            this.#connection.reset((error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve(undefined);
+    async [PRIVATE_RELEASE_METHOD]() {
+        // TODO: flip this to `if (!this.#tedious.resetConnectionOnRelease) {}` in a future PR.
+        if (this.#tedious.resetConnectionOnRelease !== false) {
+            await new Promise((resolve, reject) => {
+                this.#connection.reset((error) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(undefined);
+                });
             });
-        });
+        }
     }
     [PRIVATE_DESTROY_METHOD]() {
         return new Promise((resolve) => {

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

@@ -33,8 +33,13 @@ export declare class MysqlAdapter 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
@@ -50,6 +55,10 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -17,6 +17,10 @@ export interface MysqlDialectConfig {
      * Called once for each created connection.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+    /**
+     * Called every time a connection is acquired from the connection pool.
+     */
+    onReserveConnection?: (connection: DatabaseConnection) => Promise<void>;
 }
 /**
  * This interface is the subset of mysql2 driver's `Pool` class that

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

@@ -28,6 +28,9 @@ export class MysqlDriver {
                 await this.#config.onCreateConnection(connection);
             }
         }
+        if (this.#config?.onReserveConnection) {
+            await this.#config.onReserveConnection(connection);
+        }
         return connection;
     }
     async #acquireConnection() {

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

@@ -33,8 +33,13 @@ export declare class PostgresAdapter 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
@@ -50,6 +55,10 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *