kysely 0.18.0 → 0.19.1

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

@@ -1,103 +1,39 @@
-/// <reference types="node" />
-import * as stream from 'stream';
-import { ConnectionOptions } from 'tls';
 import { DatabaseConnection } from '../../driver/database-connection.js';
 /**
  * Config for the PostgreSQL dialect.
- *
- * This interface is equal to `pg` library's `Pool` config:
- *
- * https://node-postgres.com/api/pool
- * https://node-postgres.com/api/client
  */
 export interface PostgresDialectConfig {
     /**
-     * defaults process.env.PGUSER || process.env.USER.
-     */
-    user?: string;
-    /**
-     * default process.env.PGDATABASE || process.env.USER
-     */
-    database?: string;
-    /**
-     * default process.env.PGPASSWORD
-     */
-    password?: string | (() => string | Promise<string>);
-    /**
-     * default process.env.PGPORT
-     */
-    port?: number;
-    /**
-     * default process.env.PGHOST
-     */
-    host?: string;
-    /**
-     * e.g. postgres:*user:password@host:5432/database
-     */
-    connectionString?: string;
-    /**
-     * passed directly to node.TLSSocket, supports all tls.connect options
-     */
-    ssl?: boolean | ConnectionOptions;
-    /**
-     * Number of milliseconds to wait before timing out when connecting a new client
-     * by default this is 0 which means no timeout.
-     */
-    connectionTimeoutMillis?: number;
-    /**
-     * Maximum number of clients the pool should contain. by default this is set to 10.
-     */
-    max?: number;
-    /**
-     * Minimum number of clients the pool should contain
-     */
-    min?: number;
-    /**
-     * Number of milliseconds a client must sit idle in the pool and not be checked out
-     * before it is disconnected from the backend and discarded.
+     * A postgres Pool instance or a function that returns one.
      *
-     * default is 10000 (10 seconds) - set to 0 to disable auto-disconnection of idle clients.
-     */
-    idleTimeoutMillis?: number;
-    /**
-     * Default behavior is the pool will keep clients open & connected to the backend
-     * until idleTimeoutMillis expire for each client and node will maintain a ref
-     * to the socket on the client, keeping the event loop alive until all clients are closed
-     * after being idle or the pool is manually shutdown with `pool.end()`.
+     * If a function is provided, it's called once when the first query is executed.
      *
-     * Setting `allowExitOnIdle: true` in the config will allow the node event loop to exit
-     * as soon as all clients in the pool are idle, even if their socket is still open
-     * to the PostgreSQL server.  This can be handy in scripts & tests
-     * where you don't want to wait for your clients to go idle before your process exits.
-     */
-    allowExitOnIdle?: boolean;
-    log?: (...messages: any[]) => void;
-    /**
-     * Number of milliseconds before a statement in query will time out, default is no timeout.
+     * https://node-postgres.com/api/pool
      */
-    statement_timeout?: false | number;
-    /**
-     * Number of milliseconds before terminating any session with an open idle transaction.
-     * Default is no timeout.
-     */
-    idle_in_transaction_session_timeout?: number;
-    /**
-     * Number of milliseconds before a query call will timeout, default is no timeout.
-     */
-    query_timeout?: number;
-    /**
-     * The name of the application that created this Client instance.
-     */
-    application_name?: string;
+    pool: PostgresPool | (() => Promise<PostgresPool>);
     /**
      * Called once for each created connection.
-     *
-     * This is a Kysely specific feature and does not come from the `pg` module.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
-    keepAlive?: boolean;
-    keepAliveInitialDelayMillis?: number;
-    types?: any;
-    stream?: stream.Duplex;
-    parseInputDatesAsUTC?: boolean;
+}
+/**
+ * This interface is the subset of pg driver's `Pool` class that
+ * kysely needs.
+ *
+ * We don't use the type from `pg` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/api/pool
+ */
+export interface PostgresPool {
+    connect(): Promise<PostgresPoolClient>;
+    end(): Promise<void>;
+}
+export interface PostgresPoolClient {
+    query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
+    release(): void;
+}
+export interface PostgresQueryResult<R> {
+    command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT';
+    rowCount: number;
+    rows: R[];
 }

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

@@ -8,12 +8,32 @@ import { PostgresDialectConfig } from './postgres-dialect-config.js';
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
- * The {@link PostgresDialectConfig | configuration} passed to the constructor
- * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
- * constructor. See the following two links for more documentation:
+ * The constructor takes an instance of {@link PostgresDialectConfig}.
  *
- * https://node-postgres.com/api/pool
- * https://node-postgres.com/api/client
+ * ```ts
+ * import { Pool } from 'pg'
+ *
+ * new PostgresDialect({
+ *   pool: new Pool({
+ *     database: 'some_db',
+ *     host: 'localhost',
+ *   })
+ * })
+ * ```
+ *
+ * If you want the pool to only be created once it's first used, `pool`
+ * can be a function:
+ *
+ * ```ts
+ * import { Pool } from 'pg'
+ *
+ * new PostgresDialect({
+ *   pool: async () => new Pool({
+ *     database: 'some_db',
+ *     host: 'localhost',
+ *   })
+ * })
+ * ```
  */
 export declare class PostgresDialect implements Dialect {
     #private;

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

@@ -3,21 +3,40 @@ import { PostgresDriver } from './postgres-driver.js';
 import { PostgresIntrospector } from './postgres-introspector.js';
 import { PostgresQueryCompiler } from './postgres-query-compiler.js';
 import { PostgresAdapter } from './postgres-adapter.js';
-import { freeze } from '../../util/object-utils.js';
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
- * The {@link PostgresDialectConfig | configuration} passed to the constructor
- * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
- * constructor. See the following two links for more documentation:
+ * The constructor takes an instance of {@link PostgresDialectConfig}.
  *
- * https://node-postgres.com/api/pool
- * https://node-postgres.com/api/client
+ * ```ts
+ * import { Pool } from 'pg'
+ *
+ * new PostgresDialect({
+ *   pool: new Pool({
+ *     database: 'some_db',
+ *     host: 'localhost',
+ *   })
+ * })
+ * ```
+ *
+ * If you want the pool to only be created once it's first used, `pool`
+ * can be a function:
+ *
+ * ```ts
+ * import { Pool } from 'pg'
+ *
+ * new PostgresDialect({
+ *   pool: async () => new Pool({
+ *     database: 'some_db',
+ *     host: 'localhost',
+ *   })
+ * })
+ * ```
  */
 export class PostgresDialect {
     #config;
     constructor(config) {
-        this.#config = freeze({ ...config });
+        this.#config = config;
     }
     createDriver() {
         return new PostgresDriver(this.#config);

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

@@ -1,6 +1,8 @@
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
-import { PostgresDialectConfig } from './postgres-dialect-config.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
+declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class PostgresDriver implements Driver {
     #private;
     constructor(config: PostgresDialectConfig);
@@ -35,9 +37,16 @@ export declare class PostgresDriver implements Driver {
     /**
      * Releases a connection back to the pool.
      */
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(connection: PostgresConnection): Promise<void>;
     /**
      * Destroys the driver and releases all resources.
      */
     destroy(): Promise<void>;
 }
+declare class PostgresConnection implements DatabaseConnection {
+    #private;
+    constructor(client: PostgresPoolClient);
+    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    [PRIVATE_RELEASE_METHOD](): void;
+}
+export {};

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

@@ -1,24 +1,19 @@
 /// <reference types="./postgres-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { isFunction, freeze } from '../../util/object-utils.js';
+import { extendStackTrace } from '../../util/stack-trace-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class PostgresDriver {
     #config;
     #connections = new WeakMap();
-    #pool = null;
+    #pool;
     constructor(config) {
         this.#config = freeze({ ...config });
     }
     async init() {
-        // Import the `pg` module here instead at the top of the file
-        // so that this file can be loaded by node without `pg` driver
-        // installed. As you can see, there IS an import from `pg` at the
-        // top level too, but that's only for types. It doesn't get compiled
-        // into javascript. You can check the built javascript code.
-        const PoolConstructor = await importPgPool();
-        // Use the `pg` module's own pool. All drivers should use the
-        // pool provided by the database library if possible.
-        this.#pool = new PoolConstructor(this.#config);
+        this.#pool = isFunction(this.#config.pool)
+            ? await this.#config.pool()
+            : this.#config.pool;
     }
     async acquireConnection() {
         const client = await this.#pool.connect();
@@ -29,7 +24,7 @@ export class PostgresDriver {
             // The driver must take care of calling `onCreateConnection` when a new
             // connection is created. The `pg` module doesn't provide an async hook
             // for the connection creation. We need to call the method explicitly.
-            if (this.#config.onCreateConnection) {
+            if (this.#config?.onCreateConnection) {
                 await this.#config.onCreateConnection(connection);
             }
         }
@@ -50,52 +45,39 @@ export class PostgresDriver {
         await connection.executeQuery(CompiledQuery.raw('rollback'));
     }
     async releaseConnection(connection) {
-        const pgConnection = connection;
-        pgConnection[PRIVATE_RELEASE_METHOD]();
+        connection[PRIVATE_RELEASE_METHOD]();
     }
     async destroy() {
         if (this.#pool) {
             const pool = this.#pool;
-            this.#pool = null;
+            this.#pool = undefined;
             await pool.end();
         }
     }
 }
-async function importPgPool() {
-    try {
-        // The imported module name must be a string literal to make
-        // some bundlers work. So don't move this code behind a helper
-        // for example.
-        const pgModule = await import('pg');
-        if (isFunction(pgModule.Pool)) {
-            return pgModule.Pool;
-        }
-        else {
-            return pgModule.default.Pool;
-        }
-    }
-    catch (error) {
-        throw new Error('Postgres client not installed. Please run `npm install pg`');
-    }
-}
 class PostgresConnection {
     #client;
     constructor(client) {
         this.#client = client;
     }
     async executeQuery(compiledQuery) {
-        const result = await this.#client.query(compiledQuery.sql, [
-            ...compiledQuery.parameters,
-        ]);
-        if (result.command === 'UPDATE' || result.command === 'DELETE') {
+        try {
+            const result = await this.#client.query(compiledQuery.sql, [
+                ...compiledQuery.parameters,
+            ]);
+            if (result.command === 'UPDATE' || result.command === 'DELETE') {
+                return {
+                    numUpdatedOrDeletedRows: BigInt(result.rowCount),
+                    rows: result.rows ?? [],
+                };
+            }
             return {
-                numUpdatedOrDeletedRows: BigInt(result.rowCount),
                 rows: result.rows ?? [],
             };
         }
-        return {
-            rows: result.rows ?? [],
-        };
+        catch (err) {
+            throw extendStackTrace(err, new Error());
+        }
     }
     [PRIVATE_RELEASE_METHOD]() {
         this.#client.release();

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

@@ -1,10 +1,20 @@
-import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions } from '../database-introspector.js';
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import { Kysely } from '../../kysely.js';
 export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get schema metadata.
+     */
+    getSchemas(): Promise<SchemaMetadata[]>;
+    /**
+     * Get table 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>;
 }

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

@@ -1,12 +1,20 @@
 /// <reference types="./postgres-introspector.d.ts" />
-import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { freeze } from '../../util/object-utils.js';
 export class PostgresIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getMetadata(options = { withInternalKyselyTables: false }) {
+    async getSchemas() {
+        let rawSchemas = await this.#db
+            .selectFrom('pg_catalog.pg_namespace')
+            .select('nspname')
+            .castTo()
+            .execute();
+        return rawSchemas.map((it) => ({ name: it.nspname }));
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
             .selectFrom('pg_catalog.pg_attribute as a')
             .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
@@ -26,12 +34,15 @@ export class PostgresIntrospector {
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('t.tablename', '!=', MIGRATION_TABLE)
-                .where('t.tablename', '!=', MIGRATION_LOCK_TABLE);
+                .where('t.tablename', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('t.tablename', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const rawColumns = await query.execute();
+        return this.#parseTableMetadata(rawColumns);
+    }
+    async getMetadata(options) {
         return {
-            tables: this.#parseTableMetadata(rawColumns),
+            tables: await this.getTables(options),
         };
     }
     #parseTableMetadata(columns) {

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

@@ -1,39 +1,16 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 /**
  * Config for the SQLite dialect.
- *
- * This interface is equal to `better-sqlite3` library's `Databse` class's constructor parameters.
- *
- * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
  */
 export interface SqliteDialectConfig {
     /**
-     * The database file path.
+     * An sqlite Database instance or a function that returns one.
      *
-     * This is passed as the first argument for the [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
-     * class constructor.
-     */
-    databasePath: string;
-    /**
-     * Open the database connection in readonly mode (default: false)
-     */
-    readonly?: boolean;
-    /**
-     * If the database does not exist, an Error will be thrown instead of creating a new file.
-     * This option is ignored for in-memory, temporary, or readonly database connections
-     * (default: false)
-     */
-    fileMustExist?: boolean;
-    /**
-     * The number of milliseconds to wait when executing queries on a locked database,
-     * before throwing a SQLITE_BUSY error (default: 5000)
-     */
-    timeout?: number;
-    /**
-     * Provide a function that gets called with every SQL string executed by the database connection
-     * (default: null)
+     * If a function is provided, it's called once when the first query is executed.
+     *
+     * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
      */
-    verbose?: (sql: string) => void;
+    database: SqliteDatabase | (() => Promise<SqliteDatabase>);
     /**
      * Called once when the first query is executed.
      *
@@ -41,3 +18,23 @@ export interface SqliteDialectConfig {
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
 }
+/**
+ * This interface is the subset of better-sqlite3 driver's `Database` class that
+ * kysely needs.
+ *
+ * We don't use the type from `better-sqlite3` here to not have a dependency to it.
+ *
+ * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+ */
+export interface SqliteDatabase {
+    close(): void;
+    prepare(sql: string): SqliteStatement;
+}
+export interface SqliteStatement {
+    readonly reader: boolean;
+    all(parameters: ReadonlyArray<unknown>): unknown[];
+    run(parameters: ReadonlyArray<unknown>): {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    };
+}

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

@@ -8,9 +8,25 @@ import { SqliteDialectConfig } from './sqlite-dialect-config.js';
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
- * The {@link SqliteDialectConfig | configuration} is used to construct an instance of
- * [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
- * class. The configuration values are passed directly to the `Database` constructor.
+ * The constructor takes an instance of {@link SqliteDialectConfig}.
+ *
+ * ```ts
+ * import Database from 'better-sqlite3'
+ *
+ * new SqliteDialect({
+ *   database: new Database('db.sqlite')
+ * })
+ * ```
+ *
+ * If you want the pool to only be created once it's first used, `database`
+ * can be a function:
+ *
+ * ```ts
+ * import Database from 'better-sqlite3'
+ *
+ * new SqliteDialect({
+ *   database: async () => new Database('db.sqlite')
+ * })
  */
 export declare class SqliteDialect implements Dialect {
     #private;

package/dist/esm/dialect/sqlite/sqlite-dialect.js

@@ -7,9 +7,25 @@ import { freeze } from '../../util/object-utils.js';
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
- * The {@link SqliteDialectConfig | configuration} is used to construct an instance of
- * [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
- * class. The configuration values are passed directly to the `Database` constructor.
+ * The constructor takes an instance of {@link SqliteDialectConfig}.
+ *
+ * ```ts
+ * import Database from 'better-sqlite3'
+ *
+ * new SqliteDialect({
+ *   database: new Database('db.sqlite')
+ * })
+ * ```
+ *
+ * If you want the pool to only be created once it's first used, `database`
+ * can be a function:
+ *
+ * ```ts
+ * import Database from 'better-sqlite3'
+ *
+ * new SqliteDialect({
+ *   database: async () => new Database('db.sqlite')
+ * })
  */
 export class SqliteDialect {
     #config;

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

@@ -1,6 +1,6 @@
 /// <reference types="./sqlite-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { freeze, isBoolean, isFunction, isNumber, } from '../../util/object-utils.js';
+import { freeze, isFunction } from '../../util/object-utils.js';
 export class SqliteDriver {
     #config;
     #connectionMutex = new ConnectionMutex();
@@ -10,26 +10,9 @@ export class SqliteDriver {
         this.#config = freeze({ ...config });
     }
     async init() {
-        // Import the `better-sqlite3` module here instead at the top of the file
-        // so that this file can be loaded by node without `better-sqlite3` driver
-        // installed. As you can see, there IS an import from `better-sqlite3` at
-        // the top level too, but that's only for types. It doesn't get compiled
-        // into javascript. You can check the built javascript code.
-        const DatabaseConstructor = await importBetterSqlite3Database();
-        const options = {};
-        if (isBoolean(this.#config.readonly)) {
-            options.readonly = this.#config.readonly;
-        }
-        if (isBoolean(this.#config.fileMustExist)) {
-            options.fileMustExist = this.#config.fileMustExist;
-        }
-        if (isNumber(this.#config.timeout)) {
-            options.timeout = this.#config.timeout;
-        }
-        if (isFunction(this.#config.verbose)) {
-            options.verbose = this.#config.verbose;
-        }
-        this.#db = new DatabaseConstructor(this.#config.databasePath, options);
+        this.#db = isFunction(this.#config.database)
+            ? await this.#config.database()
+            : this.#config.database;
         this.#connection = new SqliteConnection(this.#db);
         if (this.#config.onCreateConnection) {
             await this.#config.onCreateConnection(this.#connection);
@@ -57,23 +40,6 @@ export class SqliteDriver {
         this.#db?.close();
     }
 }
-async function importBetterSqlite3Database() {
-    try {
-        // The imported module name must be a string literal to make
-        // some bundlers work. So don't move this code behind a helper
-        // for example.
-        const sqliteModule = await import('better-sqlite3');
-        if (isFunction(sqliteModule)) {
-            return sqliteModule;
-        }
-        else {
-            return sqliteModule.default;
-        }
-    }
-    catch (error) {
-        throw new Error('SQLite client not installed. Please run `npm install better-sqlite3`');
-    }
-}
 class SqliteConnection {
     #db;
     constructor(db) {

package/dist/esm/dialect/sqlite/sqlite-introspector.d.ts

@@ -1,10 +1,20 @@
-import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions } from '../database-introspector.js';
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import { Kysely } from '../../kysely.js';
 export declare class SqliteIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
+    /**
+     * Get schema metadata.
+     */
+    getSchemas(): Promise<SchemaMetadata[]>;
+    /**
+     * Get table 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>;
 }

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -1,12 +1,16 @@
 /// <reference types="./sqlite-introspector.d.ts" />
-import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { sql } from '../../raw-builder/sql.js';
 export class SqliteIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getMetadata(options = { withInternalKyselyTables: false }) {
+    async getSchemas() {
+        // Sqlite doesn't support schemas.
+        return [];
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
             .selectFrom('sqlite_schema')
             .where('type', '=', 'table')
@@ -15,12 +19,15 @@ export class SqliteIntrospector {
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('name', '!=', MIGRATION_TABLE)
-                .where('name', '!=', MIGRATION_LOCK_TABLE);
+                .where('name', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const tables = await query.execute();
+        return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+    }
+    async getMetadata(options) {
         return {
-            tables: await Promise.all(tables.map(({ name }) => this.#getTableMetadata(name))),
+            tables: await this.getTables(options),
         };
     }
     async #getTableMetadata(table) {