kysely 0.28.17 → 0.29.0

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

@@ -0,0 +1,205 @@
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { InsertResult } from '../query-builder/insert-result.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { KyselyTypeError } from './type-error.js';
+/**
+ * Given a database type and a union of table names in that db, returns
+ * a union type with all possible column names.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Person {
+ *   id: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * interface Movie {
+ *   stars: number
+ * }
+ *
+ * interface Database {
+ *   person: Person
+ *   pet: Pet
+ *   movie: Movie
+ * }
+ *
+ * type Columns = AnyColumn<Database, 'person' | 'pet'>
+ *
+ * // Columns == 'id' | 'name' | 'species'
+ * ```
+ */
+export type AnyColumn<DB, TB extends keyof DB> = {
+    [T in TB]: keyof DB[T];
+}[TB] & string;
+/**
+ * Extracts a column type.
+ */
+export type ExtractColumnType<DB, TB extends keyof DB, C> = {
+    [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+}[TB];
+/**
+ * Given a database type and a union of table names in that db, returns
+ * a union type with all possible `table`.`column` combinations.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Person {
+ *   id: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * interface Movie {
+ *   stars: number
+ * }
+ *
+ * interface Database {
+ *   person: Person
+ *   pet: Pet
+ *   movie: Movie
+ * }
+ *
+ * type Columns = AnyColumnWithTable<Database, 'person' | 'pet'>
+ *
+ * // Columns == 'person.id' | 'pet.name' | 'pet.species'
+ * ```
+ */
+export type AnyColumnWithTable<DB, TB extends keyof DB> = {
+    [T in TB]: `${T & string}.${keyof DB[T] & string}`;
+}[TB];
+/**
+ * Just like {@link AnyColumn} but with a ` as <string>` suffix.
+ */
+export type AnyAliasedColumn<DB, TB extends keyof DB> = `${AnyColumn<DB, TB>} as ${string}`;
+/**
+ * Just like {@link AnyColumnWithTable} but with a ` as <string>` suffix.
+ */
+export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = `${AnyColumnWithTable<DB, TB>} as ${string}`;
+/**
+ * Extracts the item type of an array.
+ */
+export type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+export type SimplifySingleResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O : Simplify<O> | undefined;
+export type SimplifyResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O : Simplify<O>;
+export type Simplify<T> = DrainOuterGeneric<{
+    [K in keyof T]: T[K];
+} & {}>;
+/**
+ * Represents a database row whose column names and their types are unknown.
+ */
+export type UnknownRow = Record<string, unknown>;
+/**
+ * Makes all properties of object type `T` nullable.
+ */
+export type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+/**
+ * Evaluates to `true` if `T` is `never`.
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if `T` is nullable.
+ */
+export type IsNullable<T> = [T] extends [NonNullable<T>] ? false : true;
+/**
+ * Evaluates to `true` if `T` is `any`.
+ */
+export type IsAny<T> = 0 extends T & 1 ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
+export type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export type NarrowPartial<O, T> = T extends object ? DrainOuterGeneric<{
+    [K in keyof O & string]: K extends keyof T ? T[K] extends NotNull ? Exclude<O[K], null> : T[K] extends object ? SimplifyDeep<O[K] & NarrowPartial<O[K], T[K]>> : T[K] extends O[K] ? T[K] : KyselyTypeError<`$narrowType() call failed: passed type does not exist in '${K}'s type union`> : O[K];
+}> : never;
+export type SimplifyDeep<T> = T extends object ? T extends Date | RegExp | Map<any, any> | Set<any> ? T : DrainOuterGeneric<{
+    [K in keyof T]: SimplifyDeep<T[K]>;
+} & {}> : T;
+/**
+ * A type constant for marking a column as not null. Can be used with `$narrowPartial`.
+ *
+ * Example:
+ *
+ * ```ts
+ * import type { NotNull } from 'kysely'
+ *
+ * await db.selectFrom('person')
+ *   .where('nullable_column', 'is not', null)
+ *   .selectAll()
+ *   .$narrowType<{ nullable_column: NotNull }>()
+ *   .executeTakeFirstOrThrow()
+ * ```
+ */
+export type NotNull = {
+    readonly __notNull__: unique symbol;
+};
+export type SqlBool = boolean | 0 | 1;
+/**
+ * Utility to reduce depth of TypeScript's internal type instantiation stack.
+ *
+ * Example:
+ *
+ * ```ts
+ * type A<T> = { item: T }
+ *
+ * type Test<T> = A<
+ *   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)
+ * ```
+ *
+ * To fix this, we can use `DrainOuterGeneric`:
+ *
+ * ```ts
+ * type A<T> = DrainOuterGeneric<{ item: T }>
+ *
+ * type Test<T> = A<
+ *  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 Ok = Test<number> // Ok
+ * ```
+ */
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+    [P in K]: T;
+}>;
+/**
+ * Dehydrates any root properties of an object that are not valid JSON types.
+ *
+ * For now, we catch anything in {@link StringsWhenDataTypeNotAvailable} and convert it to `string`.
+ */
+export type ShallowDehydrateObject<O> = {
+    [K in keyof O]: ShallowDehydrateValue<O[K]>;
+};
+/**
+ * Dehydrates a value when it is not a valid JSON type.
+ *
+ * For now, we catch anything in {@link StringsWhenDataTypeNotAvailable} and convert it to `string`,
+ * and anything in {@link NumbersWhenDataTypeNotAvailable} and convert it to `number`.
+ */
+export type ShallowDehydrateValue<T> = T extends null | undefined ? T : '__kysely_dehydrate__' extends keyof T & {} ? T : T & {} extends (infer U)[] ? Array<ShallowDehydrateValue<U>> | Extract<T, null | undefined> : Exclude<T, StringsWhenDataTypeNotAvailable | NumbersWhenDataTypeNotAvailable> | (IsNever<Extract<T, NumbersWhenDataTypeNotAvailable>> extends true ? never : number) | (IsNever<Extract<T, StringsWhenDataTypeNotAvailable>> extends true ? never : string);
+export type StringsWhenDataTypeNotAvailable = Date | Uint8Array;
+export type NumbersWhenDataTypeNotAvailable = bigint | NumericString;
+export type NumericString = `${number}`;
+/**
+ * Forces all properties of `T` to be present in an object literal,
+ * while still allowing `undefined` values for optional properties.
+ *
+ * Unlike `Required<T>`, this does not strip `undefined` from property types.
+ */
+export type AllProps<T> = T & {
+    [P in keyof T]-?: unknown;
+};

package/outdated-typescript.d.ts

@@ -1,5 +1,5 @@
-import type { KyselyTypeError } from './dist/cjs/util/type-error'
+import type { KyselyTypeError } from './dist/util/type-error'
 
-declare const Kysely: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 4.6 or newer.'>
-declare const RawBuilder: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 4.6 or newer.'>
-declare const sql: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 4.6 or newer.'>
+declare const Kysely: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 5.4 or newer.'>
+declare const RawBuilder: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 5.4 or newer.'>
+declare const sql: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 5.4 or newer.'>

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "kysely",
-  "version": "0.28.17",
+  "version": "0.29.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
-    "url": "git://github.com/kysely-org/kysely.git"
+    "url": "git+https://github.com/kysely-org/kysely.git"
   },
   "homepage": "https://kysely.dev",
   "keywords": [
@@ -25,13 +25,13 @@
     "plugins"
   ],
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "type": "module",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "typesVersions": {
-    "<4.6": {
+    "<5.4": {
       "*": [
         "outdated-typescript.d.ts"
       ]
@@ -39,35 +39,19 @@
   },
   "files": [
     "dist",
-    "helpers",
     "outdated-typescript.d.ts"
   ],
   "exports": {
     ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js",
-      "default": "./dist/cjs/index.js"
+      "types@<5.4": "./outdated-typescript.d.ts",
+      "default": "./dist/index.js"
     },
-    "./helpers/postgres": {
-      "import": "./dist/esm/helpers/postgres.js",
-      "require": "./dist/cjs/helpers/postgres.js",
-      "default": "./dist/cjs/helpers/postgres.js"
-    },
-    "./helpers/mysql": {
-      "import": "./dist/esm/helpers/mysql.js",
-      "require": "./dist/cjs/helpers/mysql.js",
-      "default": "./dist/cjs/helpers/mysql.js"
-    },
-    "./helpers/mssql": {
-      "import": "./dist/esm/helpers/mssql.js",
-      "require": "./dist/cjs/helpers/mssql.js",
-      "default": "./dist/cjs/helpers/mssql.js"
-    },
-    "./helpers/sqlite": {
-      "import": "./dist/esm/helpers/sqlite.js",
-      "require": "./dist/cjs/helpers/sqlite.js",
-      "default": "./dist/cjs/helpers/sqlite.js"
-    }
+    "./helpers/mssql": "./dist/helpers/mssql.js",
+    "./helpers/mysql": "./dist/helpers/mysql.js",
+    "./helpers/postgres": "./dist/helpers/postgres.js",
+    "./helpers/sqlite": "./dist/helpers/sqlite.js",
+    "./migration": "./dist/migration/index.js",
+    "./readonly": "./dist/readonly/index.js"
   },
   "sideEffects": false,
   "author": "Sami Koskimäki <sami@jakso.me>",
@@ -79,40 +63,43 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.2",
     "@ark/attest": "0.56.0",
+    "@electric-sql/pglite": "0.4.5",
     "@types/better-sqlite3": "7.6.13",
     "@types/chai": "5.2.3",
     "@types/chai-as-promised": "8.0.2",
     "@types/mocha": "10.0.10",
-    "@types/node": "25.5.2",
+    "@types/node": "25.6.1",
     "@types/pg": "8.20.0",
     "@types/pg-cursor": "2.7.2",
+    "@types/prototype-pollution-vulnerable-lodash.merge-dont-upgrade": "npm:@types/lodash.merge@4.6.1",
     "@types/semver": "7.7.1",
     "@types/sinon": "21.0.1",
-    "better-sqlite3": "12.8.0",
+    "better-sqlite3": "12.9.0",
     "chai": "6.2.2",
     "chai-as-promised": "8.0.2",
     "esbuild": "0.28.0",
     "jsr": "0.14.3",
     "lodash": "4.18.1",
     "mocha": "11.7.5",
-    "mysql2": "3.21.0",
+    "mysql2": "3.22.3",
     "pathe": "2.0.3",
     "pg": "8.20.0",
     "pg-cursor": "2.19.0",
-    "pkg-types": "2.3.0",
     "playwright": "1.59.1",
-    "prettier": "3.8.1",
+    "prettier": "3.8.3",
+    "prototype-pollution-vulnerable-lodash.merge-dont-upgrade": "npm:lodash.merge@4.6.1",
     "semver": "7.7.4",
-    "sinon": "21.0.3",
-    "std-env": "4.0.0",
+    "sinon": "22.0.0",
+    "std-env": "4.1.0",
     "tarn": "3.0.2",
     "tedious": "19.2.1",
     "tsd": "0.33.0",
-    "typescript": "6.0.2"
+    "tsx": "4.21.0",
+    "typescript": "6.0.3"
   },
   "scripts": {
-    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js & rm -rf helpers",
-    "bench:ts": "pnpm build && cd ./test/ts-benchmarks && node --experimental-strip-types ./index.ts",
+    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js",
+    "bench:ts": "pnpm build && node --experimental-strip-types ./test/ts-benchmarks/index.ts",
     "test": "pnpm build && pnpm test:node:build && pnpm test:node:run && pnpm test:typings && pnpm test:esmimports && pnpm test:exports",
     "test:node:build": "tsc -p test/node",
     "test:node": "pnpm build && pnpm test:node:build && pnpm test:node:run",
@@ -124,21 +111,18 @@
     "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/test.ts",
     "test:typings": "tsd test/typings",
     "test:esmimports": "node scripts/check-esm-imports.cjs",
-    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
-    "test:exports": "attw --pack . && node scripts/check-exports.cjs",
+    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/index.js --outfile=/dev/null",
+    "test:exports": "attw --profile esm-only --pack . && node scripts/check-exports.cjs",
     "test:jsdocs": "deno check --doc-only --no-lock --unstable-sloppy-imports --config=\"deno.check.json\" ./src",
     "test:outdatedts": "pnpm build && cd test/outdated-ts && pnpm i && pnpm test",
     "lint:deno": "deno lint --config=\"deno.lint.json\" ./src",
     "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
-    "build": "pnpm clean && (pnpm build:esm & pnpm build:cjs) && pnpm script:module-fixup && pnpm script:copy-interface-doc",
-    "build:esm": "tsc -p tsconfig.json && pnpm script:add-deno-type-references",
-    "build:cjs": "tsc -p tsconfig-cjs.json",
-    "script:module-fixup": "node scripts/module-fixup.cjs",
+    "build": "pnpm clean && tsc && pnpm script:add-deno-type-references && pnpm script:copy-interface-doc",
     "script:copy-interface-doc": "node scripts/copy-interface-documentation.cjs",
     "script:add-deno-type-references": "node scripts/add-deno-type-references.cjs",
     "script:align-versions": "node --experimental-strip-types scripts/align-versions.mts",
     "script:generate-site-examples": "node scripts/generate-site-examples.cjs",
-    "script:exclude-test-files-for-backwards-compat": "node --experimental-strip-types scripts/exclude-test-files-for-backwards-compat.mts",
+    "script:override-tsconfig-target": "node --experimental-strip-types scripts/override-tsconfig-target.mts",
     "script:remove-global-augmentations": "node --experimental-strip-types scripts/remove-global-augmentations.mts",
     "version": "pnpm script:align-versions && git add ."
   }

package/dist/cjs/dialect/database-introspector.d.ts

@@ -1,62 +0,0 @@
-/**
- * An interface for getting the database metadata (names of the tables and columns etc.)
- */
-export interface DatabaseIntrospector {
-    /**
-     * Get schema metadata.
-     */
-    getSchemas(): Promise<SchemaMetadata[]>;
-    /**
-     * Get tables and views metadata.
-     */
-    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
-}
-export interface DatabaseMetadataOptions {
-    /**
-     * If this is true, the metadata contains the internal kysely tables
-     * such as the migration tables.
-     */
-    withInternalKyselyTables: boolean;
-}
-export interface SchemaMetadata {
-    readonly name: string;
-}
-export interface DatabaseMetadata {
-    /**
-     * The tables and views found in the database.
-     * The propery isView can be used to tell them apart.
-     */
-    readonly tables: TableMetadata[];
-}
-export interface TableMetadata {
-    readonly name: string;
-    readonly isView: boolean;
-    readonly columns: ColumnMetadata[];
-    readonly schema?: string;
-}
-export interface ColumnMetadata {
-    readonly name: string;
-    /**
-     * The data type of the column as reported by the database.
-     *
-     * NOTE: This value is whatever the database engine returns and it will be
-     *       different on different dialects even if you run the same migrations.
-     *       For example `integer` datatype in a migration will produce `int4`
-     *       on PostgreSQL, `INTEGER` on SQLite and `int` on MySQL.
-     */
-    readonly dataType: string;
-    /**
-     * The schema this column's data type was created in.
-     */
-    readonly dataTypeSchema?: string;
-    readonly isAutoIncrementing: boolean;
-    readonly isNullable: boolean;
-    readonly hasDefaultValue: boolean;
-    readonly comment?: string;
-}

package/dist/cjs/dialect/database-introspector.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,94 +0,0 @@
-import type { Kysely } from '../kysely.js';
-import type { DialectAdapter, MigrationLockOptions } from './dialect-adapter.js';
-/**
- * A basic implementation of `DialectAdapter` with sensible default values.
- * 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.
- */
-export declare abstract class DialectAdapterBase implements 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.
-     */
-    get supportsCreateIfNotExists(): boolean;
-    /**
-     * Whether or not this dialect supports transactional DDL.
-     *
-     * 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.
-     *
-     * 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.
-     */
-    abstract 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.
-     */
-    abstract releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
-}

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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DialectAdapterBase = void 0;
-/**
- * A basic implementation of `DialectAdapter` with sensible default values.
- * 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.
- */
-class DialectAdapterBase {
-    get supportsCreateIfNotExists() {
-        return true;
-    }
-    get supportsTransactionalDdl() {
-        return false;
-    }
-    get supportsReturning() {
-        return false;
-    }
-    get supportsOutput() {
-        return false;
-    }
-}
-exports.DialectAdapterBase = DialectAdapterBase;

package/dist/cjs/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;
-}