kysely 0.12.2 → 0.13.0

package/dist/cjs/migration/migration.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrationModule = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
+exports.MigrationModule = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
 const path = require("path");
 const fs_1 = require("fs");
 const object_utils_js_1 = require("../util/object-utils.js");
 exports.MIGRATION_TABLE = 'kysely_migration';
 exports.MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 exports.MIGRATION_LOCK_ID = 'migration_lock';
+exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true });
 class MigrationModule {
     #db;
     #adapter;
@@ -15,171 +16,291 @@ class MigrationModule {
         this.#adapter = adapter;
     }
     async migrateToLatest(migrationsOrFolderPath) {
-        await ensureMigrationTablesExists(this.#db);
-        const allMigrations = await this.#getAllMigrations(migrationsOrFolderPath);
-        await this.#migrateToLatest(allMigrations);
+        return this.#migrate(migrationsOrFolderPath, ({ migrations }) => migrations.length - 1);
     }
-    async #getAllMigrations(migrationsOrFolderPath) {
-        return (0, object_utils_js_1.isString)(migrationsOrFolderPath)
-            ? await readMigrationsFromFolder(migrationsOrFolderPath)
-            : migrationsOrFolderPath;
+    async migrateTo(migrationsOrFolderPath, targetMigrationName) {
+        return this.#migrate(migrationsOrFolderPath, ({ migrations }) => {
+            if (targetMigrationName === exports.NO_MIGRATIONS) {
+                return -1;
+            }
+            const index = migrations.findIndex((it) => it.name === targetMigrationName);
+            if (index === -1) {
+                throw new Error(`migration "${targetMigrationName}" doesn't exist`);
+            }
+            return index;
+        });
+    }
+    async migrateUp(migrationsOrFolderPath) {
+        return this.#migrate(migrationsOrFolderPath, ({ currentIndex, migrations }) => Math.min(currentIndex + 1, migrations.length - 1));
+    }
+    async migrateDown(migrationsOrFolderPath) {
+        return this.#migrate(migrationsOrFolderPath, ({ currentIndex }) => Math.max(currentIndex - 1, -1));
+    }
+    async #migrate(migrationsOrFolderPath, getTargetMigration) {
+        try {
+            await this.#ensureMigrationTablesExists();
+            return await this.#runMigrations(migrationsOrFolderPath, getTargetMigration);
+        }
+        catch (error) {
+            if (error instanceof MigrationResultSetError) {
+                return error.resultSet;
+            }
+            return { error };
+        }
+    }
+    async #ensureMigrationTablesExists() {
+        await this.#ensureMigrationTableExists();
+        await this.#ensureMigrationLockTableExists();
+        await this.#ensureLockRowExists();
     }
-    async #migrateToLatest(allMigrations) {
+    async #ensureMigrationTableExists() {
+        if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
+            try {
+                await this.#db.schema
+                    .createTable(exports.MIGRATION_TABLE)
+                    .ifNotExists()
+                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                    // The migration run time as ISO string. This is not a real date type as we
+                    // can't know which data type is supported by all future dialects.
+                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull())
+                    .execute();
+            }
+            catch (error) {
+                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+                // query doesn't throw if the table already exits. That's why we check if
+                // the table exist here and ignore the error if it does.
+                if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async #ensureMigrationLockTableExists() {
+        if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
+            try {
+                await this.#db.schema
+                    .createTable(exports.MIGRATION_LOCK_TABLE)
+                    .ifNotExists()
+                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
+                    .execute();
+            }
+            catch (error) {
+                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+                // query doesn't throw if the table already exits. That's why we check if
+                // the table exist here and ignore the error if it does.
+                if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async #ensureLockRowExists() {
+        if (!(await this.#doesLockRowExists())) {
+            try {
+                await this.#db
+                    .insertInto(exports.MIGRATION_LOCK_TABLE)
+                    .values({ id: exports.MIGRATION_LOCK_ID })
+                    .execute();
+            }
+            catch (error) {
+                if (!(await this.#doesLockRowExists())) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async #doesTableExists(tableName) {
+        const metadata = await this.#db.introspection.getMetadata({
+            withInternalKyselyTables: true,
+        });
+        return !!metadata.tables.find((it) => it.name === tableName);
+    }
+    async #doesLockRowExists() {
+        const lockRow = await this.#db
+            .selectFrom(exports.MIGRATION_LOCK_TABLE)
+            .where('id', '=', exports.MIGRATION_LOCK_ID)
+            .select('id')
+            .executeTakeFirst();
+        return !!lockRow;
+    }
+    async #runMigrations(migrationsOrFolderPath, getTargetMigration) {
         const run = async (db) => {
             try {
                 await this.#adapter.acquireMigrationLock(db);
-                await runNewMigrations(db, allMigrations);
+                const state = await this.#getState(db, migrationsOrFolderPath);
+                if (state.migrations.length === 0) {
+                    return { results: [] };
+                }
+                const targetIndex = getTargetMigration(state);
+                if (targetIndex === undefined) {
+                    return { results: [] };
+                }
+                if (targetIndex < state.currentIndex) {
+                    return await this.#migrateDown(db, state, targetIndex);
+                }
+                else if (targetIndex > state.currentIndex) {
+                    return await this.#migrateUp(db, state, targetIndex);
+                }
+                return { results: [] };
             }
             finally {
                 await this.#adapter.releaseMigrationLock(db);
             }
         };
         if (this.#adapter.supportsTransactionalDdl) {
-            await this.#db.transaction().execute(run);
+            return this.#db.transaction().execute(run);
         }
         else {
-            await this.#db.connection().execute(run);
+            return this.#db.connection().execute(run);
         }
     }
-}
-exports.MigrationModule = MigrationModule;
-async function ensureMigrationTablesExists(db) {
-    await ensureMigrationTableExists(db);
-    await ensureMigrationLockTableExists(db);
-    await ensureLockRowExists(db);
-}
-async function ensureMigrationTableExists(db) {
-    if (!(await doesTableExists(db, exports.MIGRATION_TABLE))) {
-        try {
-            await db.schema
-                .createTable(exports.MIGRATION_TABLE)
-                .ifNotExists()
-                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                // The migration run time as ISO string. This is not a real date type as we
-                // can't know which data type is supported by all future dialects.
-                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull())
-                .execute();
-        }
-        catch (error) {
-            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-            // query doesn't throw if the table already exits. That's why we check if
-            // the table exist here and ignore the error if it does.
-            if (!(await doesTableExists(db, exports.MIGRATION_TABLE))) {
-                throw error;
+    async #getState(db, migrationsOrFolderPath) {
+        const migrations = await this.#resolveMigrations(migrationsOrFolderPath);
+        const executedMigrations = await this.#getExecutedMigrations(db);
+        this.#ensureMigrationsNotCorrupted(migrations, executedMigrations);
+        return (0, object_utils_js_1.freeze)({
+            migrations,
+            currentIndex: migrations.findIndex((it) => it.name === (0, object_utils_js_1.getLast)(executedMigrations)),
+        });
+    }
+    async #resolveMigrations(migrationsOrFolderPath) {
+        const allMigrations = (0, object_utils_js_1.isString)(migrationsOrFolderPath)
+            ? await this.#readMigrationsFromFolder(migrationsOrFolderPath)
+            : migrationsOrFolderPath;
+        return Object.keys(allMigrations)
+            .sort()
+            .map((name) => ({
+            ...allMigrations[name],
+            name,
+        }));
+    }
+    async #readMigrationsFromFolder(migrationsFolderPath) {
+        const files = await fs_1.promises.readdir(migrationsFolderPath);
+        const migrations = {};
+        for (const file of files) {
+            if ((file.endsWith('.js') || file.endsWith('.ts')) &&
+                !file.endsWith('.d.ts')) {
+                const migration = await Promise.resolve().then(() => require(path.join(migrationsFolderPath, file)));
+                if (isMigration(migration)) {
+                    migrations[file.substring(0, file.length - 3)] = migration;
+                }
             }
         }
+        return migrations;
     }
-}
-async function ensureMigrationLockTableExists(db) {
-    if (!(await doesTableExists(db, exports.MIGRATION_LOCK_TABLE))) {
-        try {
-            await db.schema
-                .createTable(exports.MIGRATION_LOCK_TABLE)
-                .ifNotExists()
-                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
-                .execute();
+    async #getExecutedMigrations(db) {
+        const executedMigrations = await db
+            .selectFrom(exports.MIGRATION_TABLE)
+            .select('name')
+            .orderBy('name')
+            .execute();
+        return executedMigrations.map((it) => it.name);
+    }
+    #ensureMigrationsNotCorrupted(migrations, executedMigrations) {
+        for (const executed of executedMigrations) {
+            if (!migrations.some((it) => it.name === executed)) {
+                throw new Error(`corrupted migrations: previously executed migration ${executed} is missing`);
+            }
         }
-        catch (error) {
-            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-            // query doesn't throw if the table already exits. That's why we check if
-            // the table exist here and ignore the error if it does.
-            if (!(await doesTableExists(db, exports.MIGRATION_LOCK_TABLE))) {
-                throw error;
+        // Now we know all executed migrations exist in the `migrations` list.
+        // Next we need to make sure that the executed migrations are the first
+        // ones in the migration list.
+        for (let i = 0; i < executedMigrations.length; ++i) {
+            if (migrations[i].name !== executedMigrations[i]) {
+                throw new Error(`corrupted migrations: expected previously executed migration ${executedMigrations[i]} to be at index ${i} but ${migrations[i].name} was found in its place. New migrations must always have a name that comes alphabetically after the last executed migration.`);
             }
         }
     }
-}
-async function ensureLockRowExists(db) {
-    if (!(await doesLockRowExists(db))) {
-        try {
-            await db
-                .insertInto(exports.MIGRATION_LOCK_TABLE)
-                .values({ id: exports.MIGRATION_LOCK_ID })
-                .execute();
+    async #migrateDown(db, state, targetIndex) {
+        const results = [];
+        for (let i = state.currentIndex; i > targetIndex; --i) {
+            results.push({
+                migrationName: state.migrations[i].name,
+                direction: 'Down',
+                status: 'NotExecuted',
+            });
         }
-        catch (error) {
-            if (!(await doesLockRowExists(db))) {
-                throw error;
+        for (let i = 0; i < results.length; ++i) {
+            const migration = state.migrations.find((it) => it.name === results[i].migrationName);
+            try {
+                if (migration.down) {
+                    await migration.down(db);
+                    await db
+                        .deleteFrom(exports.MIGRATION_TABLE)
+                        .where('name', '=', migration.name)
+                        .execute();
+                    results[i] = {
+                        migrationName: migration.name,
+                        direction: 'Down',
+                        status: 'Success',
+                    };
+                }
+            }
+            catch (error) {
+                results[i] = {
+                    migrationName: migration.name,
+                    direction: 'Down',
+                    status: 'Error',
+                };
+                throw new MigrationResultSetError({
+                    error,
+                    results,
+                });
             }
         }
+        return { results };
     }
-}
-async function doesTableExists(db, tableName) {
-    const metadata = await db.introspection.getMetadata({
-        withInternalKyselyTables: true,
-    });
-    return !!metadata.tables.find((it) => it.name === tableName);
-}
-async function doesLockRowExists(db) {
-    const lockRow = await db
-        .selectFrom(exports.MIGRATION_LOCK_TABLE)
-        .where('id', '=', exports.MIGRATION_LOCK_ID)
-        .select('id')
-        .executeTakeFirst();
-    return !!lockRow;
-}
-async function readMigrationsFromFolder(migrationsFolderPath) {
-    const files = await fs_1.promises.readdir(migrationsFolderPath);
-    const migrations = {};
-    for (const file of files) {
-        if ((file.endsWith('.js') || file.endsWith('.ts')) &&
-            !file.endsWith('.d.ts')) {
-            const migration = await Promise.resolve().then(() => require(path.join(migrationsFolderPath, file)));
-            if (isMigration(migration)) {
-                migrations[file.substring(0, file.length - 3)] = migration;
+    async #migrateUp(db, state, targetIndex) {
+        const results = [];
+        for (let i = state.currentIndex + 1; i <= targetIndex; ++i) {
+            results.push({
+                migrationName: state.migrations[i].name,
+                direction: 'Up',
+                status: 'NotExecuted',
+            });
+        }
+        for (let i = 0; i < results.length; ++i) {
+            const migration = state.migrations.find((it) => it.name === results[i].migrationName);
+            try {
+                await migration.up(db);
+                await db
+                    .insertInto(exports.MIGRATION_TABLE)
+                    .values({
+                    name: migration.name,
+                    timestamp: new Date().toISOString(),
+                })
+                    .execute();
+                results[i] = {
+                    migrationName: migration.name,
+                    direction: 'Up',
+                    status: 'Success',
+                };
+            }
+            catch (error) {
+                results[i] = {
+                    migrationName: migration.name,
+                    direction: 'Up',
+                    status: 'Error',
+                };
+                throw new MigrationResultSetError({
+                    error,
+                    results,
+                });
             }
         }
-    }
-    return migrations;
-}
-async function runNewMigrations(db, allMigrations) {
-    const sortedMigrations = Object.keys(allMigrations)
-        .sort()
-        .map((name) => ({
-        ...allMigrations[name],
-        name,
-    }));
-    const executedMigrations = await db
-        .selectFrom(exports.MIGRATION_TABLE)
-        .select('name')
-        .orderBy('name')
-        .execute();
-    const lastExecuted = (0, object_utils_js_1.getLast)(executedMigrations);
-    const lastExecutedIndex = sortedMigrations.findIndex((it) => it.name === lastExecuted?.name);
-    if (lastExecuted && lastExecutedIndex === -1) {
-        throw new Error(`corrupted migrations: previously executed migration ${lastExecuted.name} is missing`);
-    }
-    const oldMigrations = lastExecuted
-        ? sortedMigrations.slice(0, lastExecutedIndex + 1)
-        : [];
-    const newMigrations = lastExecuted
-        ? sortedMigrations.slice(lastExecutedIndex + 1)
-        : sortedMigrations;
-    ensureMigrationsAreNotCorrupted(executedMigrations.map((it) => it.name), oldMigrations.map((it) => it.name));
-    for (const migration of newMigrations) {
-        await migration.up(db);
-        await db
-            .insertInto(exports.MIGRATION_TABLE)
-            .values({
-            name: migration.name,
-            timestamp: new Date().toISOString(),
-        })
-            .execute();
+        return { results };
     }
 }
-function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNames) {
-    const executedSet = new Set(executedMigrationNames);
-    const oldMigrationSet = new Set(oldMigrationNames);
-    for (const it of executedSet) {
-        if (!oldMigrationSet.has(it)) {
-            throw new Error(`corrupted migrations: previously executed migration ${it} is missing`);
-        }
+exports.MigrationModule = MigrationModule;
+class MigrationResultSetError extends Error {
+    #resultSet;
+    constructor(result) {
+        super();
+        this.#resultSet = result;
     }
-    for (const it of oldMigrationSet) {
-        if (!executedSet.has(it)) {
-            throw new Error(`corrupted migrations: new migration ${it} comes alphabetically before the last executed migration. New migrations must always have a name that comes alphabetically after the last executed migration.`);
-        }
+    get resultSet() {
+        return this.#resultSet;
     }
 }
 function isMigration(obj) {

package/dist/cjs/operation-node/column-definition-node.d.ts

@@ -6,20 +6,21 @@ import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
+export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
     readonly column: ColumnNode;
     readonly dataType: ColumnDataTypeNode;
     readonly references?: ReferencesNode;
-    readonly primaryKey: boolean;
-    readonly autoIncrement: boolean;
-    readonly unique: boolean;
-    readonly nullable: boolean;
+    readonly primaryKey?: boolean;
+    readonly autoIncrement?: boolean;
+    readonly unique?: boolean;
+    readonly notNull?: boolean;
     readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
     readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
+    readonly unsigned?: boolean;
 }
 /**
  * @internal

package/dist/cjs/operation-node/column-definition-node.js

@@ -15,10 +15,6 @@ exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
             kind: 'ColumnDefinitionNode',
             column: column_node_js_1.ColumnNode.create(column),
             dataType,
-            primaryKey: false,
-            autoIncrement: false,
-            unique: false,
-            nullable: true,
         });
     },
     cloneWith(node, props) {

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -284,7 +284,8 @@ class OperationNodeTransformer {
             primaryKey: node.primaryKey,
             autoIncrement: node.autoIncrement,
             unique: node.unique,
-            nullable: node.nullable,
+            notNull: node.notNull,
+            unsigned: node.unsigned,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
             generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -12,8 +12,8 @@ export interface CamelCasePluginOptions {
     upperCase?: boolean;
     /**
      * If true, an underscore is added before each digit when converting
-     * camelCase to snake_case. For example `foo1Bar => foo_1_bar` and
-     * `foo_1_bar => foo1Bar`
+     * camelCase to snake_case. For example `foo12Bar => foo_12_bar` and
+     * `foo_12_bar => foo12Bar`
      *
      * Defaults to false.
      */

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -324,6 +324,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.visitNode(node.column);
         this.append(' ');
         this.visitNode(node.dataType);
+        if (node.unsigned) {
+            this.append(' unsigned');
+        }
         if (node.generatedAlwaysAs) {
             this.append(' ');
             this.visitNode(node.generatedAlwaysAs);
@@ -332,7 +335,7 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.defaultTo);
         }
-        if (!node.nullable) {
+        if (node.notNull) {
             this.append(' not null');
         }
         if (node.unique) {

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -124,6 +124,12 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * Adds a `not null` constraint for the column.
      */
     notNull(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): AlterTableAddColumnBuilder;
     /**
      * Adds a default value constraint for the column.
      *
@@ -253,6 +259,12 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * Adds a `not null` constraint for the column.
      */
     notNull(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): AlterTableModifyColumnBuilder;
     /**
      * Adds a default value constraint for the column.
      *

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

@@ -232,6 +232,12 @@ class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.notNull(),
         });
     }
+    unsigned() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.unsigned(),
+        });
+    }
     defaultTo(value) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -316,6 +322,12 @@ class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.notNull(),
         });
     }
+    unsigned() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.unsigned(),
+        });
+    }
     defaultTo(value) {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -66,6 +66,12 @@ export interface ColumnDefinitionBuilderInterface {
      * Adds a `not null` constraint for the column.
      */
     notNull(): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a default value constraint for the column.
      *
@@ -189,6 +195,12 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * Adds a `not null` constraint for the column.
      */
     notNull(): ColumnDefinitionBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): ColumnDefinitionBuilder;
     /**
      * Adds a default value constraint for the column.
      *

package/dist/cjs/schema/column-definition-builder.js

@@ -53,7 +53,10 @@ class ColumnDefinitionBuilder {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
     }
     notNull() {
-        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { nullable: false }));
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));
+    }
+    unsigned() {
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {

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

@@ -1,6 +1,6 @@
 import { Kysely } from '../../kysely.js';
-import { DialectAdapter } from '../dialect-adapter.js';
-export declare class MysqlAdapter implements DialectAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export declare class MysqlAdapter extends DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
      *

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

@@ -1,6 +1,7 @@
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
 const LOCK_ID = 'ea586330-2c93-47c8-908d-981d9d270f9d';
 const LOCK_TIMEOUT_SECONDS = 60 * 60;
-export class MysqlAdapter {
+export class MysqlAdapter extends DialectAdapterBase {
     get supportsTransactionalDdl() {
         return false;
     }

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

@@ -1,6 +1,6 @@
 import { Kysely } from '../../kysely.js';
-import { DialectAdapter } from '../dialect-adapter.js';
-export declare class PostgresAdapter implements DialectAdapter {
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export declare class PostgresAdapter extends DialectAdapterBase {
     /**
      * Whether or not this dialect supports transactional DDL.
      *

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

@@ -1,6 +1,7 @@
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
 // Random id for our transaction lock.
 const LOCK_ID = '3853314791062309107';
-export class PostgresAdapter {
+export class PostgresAdapter extends DialectAdapterBase {
     get supportsTransactionalDdl() {
         return true;
     }