kysely 0.18.0 → 0.18.1

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

@@ -3,8 +3,18 @@ import { ColumnDataType } from '../operation-node/data-type-node.js';
  * An interface for getting the database metadata (names of the tables and columns etc.)
  */
 export interface DatabaseIntrospector {
+    /**
+     * 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>;
 }
@@ -15,6 +25,9 @@ export interface DatabaseMetadataOptions {
      */
     withInternalKyselyTables: boolean;
 }
+export interface SchemaMetadata {
+    readonly name: string;
+}
 export interface DatabaseMetadata {
     /**
      * The tables found in the database.

package/dist/cjs/dialect/mysql/mysql-dialect.d.ts

@@ -3,6 +3,7 @@ import { Kysely } from '../../kysely.js';
 import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../database-introspector.js';
+import { MysqlPool } from './mysql-driver.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { MysqlDialectConfig } from './mysql-dialect-config.js';
 /**
@@ -11,10 +12,17 @@ import { MysqlDialectConfig } from './mysql-dialect-config.js';
  * The {@link MysqlDialectConfig | configuration} passed to the constructor
  * is given as-is to the mysql2 library's [createPool](https://github.com/sidorares/node-mysql2#using-connection-pools)
  * method.
+ *
+ * You can also provide an existing mysql2 `Pool` instance:
+ *
+ * ```ts
+ * import { createPool } from 'mysql2'
+ * new MysqlDialect(createPool(config))
+ * ```
  */
 export declare class MysqlDialect implements Dialect {
     #private;
-    constructor(config: MysqlDialectConfig);
+    constructor(configOrPool: MysqlDialectConfig | MysqlPool);
     /**
      * Creates a driver for the dialect.
      */

package/dist/cjs/dialect/mysql/mysql-dialect.js

@@ -5,21 +5,27 @@ const mysql_driver_js_1 = require("./mysql-driver.js");
 const mysql_query_compiler_js_1 = require("./mysql-query-compiler.js");
 const mysql_introspector_js_1 = require("./mysql-introspector.js");
 const mysql_adapter_js_1 = require("./mysql-adapter.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
 /**
  * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
  *
  * The {@link MysqlDialectConfig | configuration} passed to the constructor
  * is given as-is to the mysql2 library's [createPool](https://github.com/sidorares/node-mysql2#using-connection-pools)
  * method.
+ *
+ * You can also provide an existing mysql2 `Pool` instance:
+ *
+ * ```ts
+ * import { createPool } from 'mysql2'
+ * new MysqlDialect(createPool(config))
+ * ```
  */
 class MysqlDialect {
-    #config;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
+    #configOrPool;
+    constructor(configOrPool) {
+        this.#configOrPool = configOrPool;
     }
     createDriver() {
-        return new mysql_driver_js_1.MysqlDriver(this.#config);
+        return new mysql_driver_js_1.MysqlDriver(this.#configOrPool);
     }
     createQueryCompiler() {
         return new mysql_query_compiler_js_1.MysqlQueryCompiler();

package/dist/cjs/dialect/mysql/mysql-driver.d.ts

@@ -1,9 +1,11 @@
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { MysqlDialectConfig } from './mysql-dialect-config.js';
+declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class MysqlDriver implements Driver {
     #private;
-    constructor(config: MysqlDialectConfig);
+    constructor(configOrPool: MysqlDialectConfig | MysqlPool);
     /**
      * Initializes the driver.
      *
@@ -35,9 +37,29 @@ export declare class MysqlDriver implements Driver {
     /**
      * Releases a connection back to the pool.
      */
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(connection: MysqlConnection): Promise<void>;
     /**
      * Destroys the driver and releases all resources.
      */
     destroy(): Promise<void>;
 }
+export interface MysqlPool {
+    getConnection(callback: (error: unknown, connection: MysqlPoolConnection) => void): void;
+    end(callback: (error: unknown) => void): void;
+}
+interface MysqlPoolConnection {
+    query(sql: string, parameters: ReadonlyArray<unknown>, callback: (error: unknown, result: MysqlQueryResult) => void): void;
+    release(): void;
+}
+interface MysqlOkPacket {
+    affectedRows: number;
+    insertId: number;
+}
+declare type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[];
+declare class MysqlConnection implements DatabaseConnection {
+    #private;
+    constructor(rawConnection: MysqlPoolConnection);
+    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    [PRIVATE_RELEASE_METHOD](): void;
+}
+export {};

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

@@ -3,24 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDriver = void 0;
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const stack_trace_utils_js_1 = require("../../util/stack-trace-utils.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class MysqlDriver {
     #config;
     #connections = new WeakMap();
     #pool;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
+    constructor(configOrPool) {
+        if (isMysqlPool(configOrPool)) {
+            this.#pool = configOrPool;
+        }
+        else {
+            this.#config = (0, object_utils_js_1.freeze)({ ...configOrPool });
+        }
     }
     async init() {
-        // Import the `mysql2` module here instead at the top of the file
-        // so that this file can be loaded by node without `mysql2` driver
-        // installed. As you can see, there IS an import from `mysql2` 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 poolFactory = await importMysqlPoolFactory();
-        // Use the `mysql2` module's own pool. All drivers should use the
-        // pool provided by the database library if possible.
-        this.#pool = poolFactory(this.#config);
+        if (this.#config) {
+            // Import the `mysql2` module here instead at the top of the file
+            // so that this file can be loaded by node without `mysql2` driver
+            // installed.
+            const poolFactory = await importMysqlPoolFactory();
+            // Use the `mysql2` module's own pool. All drivers should use the
+            // pool provided by the database library if possible.
+            this.#pool = poolFactory(this.#config);
+        }
     }
     async acquireConnection() {
         const rawConnection = await this.#acquireConnection();
@@ -31,7 +37,7 @@ class MysqlDriver {
             // The driver must take care of calling `onCreateConnection` when a new
             // connection is created. The `mysql2` 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);
             }
         }
@@ -63,8 +69,7 @@ class MysqlDriver {
         await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
     }
     async releaseConnection(connection) {
-        const mysqlConnection = connection;
-        mysqlConnection[PRIVATE_RELEASE_METHOD]();
+        connection[PRIVATE_RELEASE_METHOD]();
     }
     async destroy() {
         return new Promise((resolve, reject) => {
@@ -80,6 +85,12 @@ class MysqlDriver {
     }
 }
 exports.MysqlDriver = MysqlDriver;
+function isMysqlPool(obj) {
+    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.getConnection) && (0, object_utils_js_1.isFunction)(obj.end);
+}
+function isOkPacket(obj) {
+    return (0, object_utils_js_1.isObject)(obj) && 'insertId' in obj && 'affectedRows' in obj;
+}
 async function importMysqlPoolFactory() {
     try {
         // The imported module name must be a string literal to make
@@ -103,29 +114,34 @@ class MysqlConnection {
         this.#rawConnection = rawConnection;
     }
     async executeQuery(compiledQuery) {
-        const result = await this.#executeQuery(compiledQuery);
-        if (isOkPacket(result)) {
-            const { insertId, affectedRows } = result;
+        try {
+            const result = await this.#executeQuery(compiledQuery);
+            if (isOkPacket(result)) {
+                const { insertId, affectedRows } = result;
+                return {
+                    insertId: insertId !== undefined &&
+                        insertId !== null &&
+                        insertId.toString() !== '0'
+                        ? BigInt(insertId)
+                        : undefined,
+                    numUpdatedOrDeletedRows: affectedRows !== undefined && insertId !== null
+                        ? BigInt(affectedRows)
+                        : undefined,
+                    rows: [],
+                };
+            }
+            else if (Array.isArray(result)) {
+                return {
+                    rows: result,
+                };
+            }
             return {
-                insertId: insertId !== undefined &&
-                    insertId !== null &&
-                    insertId.toString() !== '0'
-                    ? BigInt(insertId)
-                    : undefined,
-                numUpdatedOrDeletedRows: affectedRows !== undefined && insertId !== null
-                    ? BigInt(affectedRows)
-                    : undefined,
                 rows: [],
             };
         }
-        else if (Array.isArray(result)) {
-            return {
-                rows: result,
-            };
+        catch (err) {
+            throw (0, stack_trace_utils_js_1.extendStackTrace)(err, new Error());
         }
-        return {
-            rows: [],
-        };
     }
     #executeQuery(compiledQuery) {
         return new Promise((resolve, reject) => {
@@ -143,6 +159,3 @@ class MysqlConnection {
         this.#rawConnection.release();
     }
 }
-function isOkPacket(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && 'insertId' in obj && 'affectedRows' in obj;
-}

package/dist/cjs/dialect/mysql/mysql-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 MysqlIntrospector 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/cjs/dialect/mysql/mysql-introspector.js

@@ -3,26 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlIntrospector = void 0;
 const migrator_js_1 = require("../../migration/migrator.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
-const sql_js_1 = require("../../raw-builder/sql.js");
 class MysqlIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getMetadata(options = { withInternalKyselyTables: false }) {
+    async getSchemas() {
+        let rawSchemas = await this.#db
+            .selectFrom('information_schema.schemata')
+            .select('schema_name')
+            .castTo()
+            .execute();
+        return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
             .selectFrom('information_schema.columns')
-            .selectAll()
-            .where('table_schema', '=', (0, sql_js_1.sql) `database()`)
+            .select([
+            'column_name',
+            'table_name',
+            'table_schema',
+            'is_nullable',
+            'data_type',
+        ])
+            .where('table_schema', 'not in', [
+            'information_schema',
+            'performance_schema',
+            'mysql',
+            'sys',
+        ])
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('table_name', '!=', migrator_js_1.MIGRATION_TABLE)
-                .where('table_name', '!=', migrator_js_1.MIGRATION_LOCK_TABLE);
+                .where('table_name', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
+                .where('table_name', '!=', migrator_js_1.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) {
@@ -31,6 +52,7 @@ class MysqlIntrospector {
             if (!table) {
                 table = (0, object_utils_js_1.freeze)({
                     name: it.TABLE_NAME,
+                    schema: it.TABLE_SCHEMA,
                     columns: [],
                 });
                 tables.push(table);

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

@@ -2,6 +2,7 @@ import { Driver } from '../../driver/driver.js';
 import { Kysely } from '../../kysely.js';
 import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
+import { PostgresPool } from './postgres-driver.js';
 import { DatabaseIntrospector } from '../database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { PostgresDialectConfig } from './postgres-dialect-config.js';
@@ -14,10 +15,17 @@ import { PostgresDialectConfig } from './postgres-dialect-config.js';
  *
  * https://node-postgres.com/api/pool
  * https://node-postgres.com/api/client
+ *
+ * You can also provide an existing pg `Pool` instance:
+ *
+ * ```ts
+ * import { Pool } from 'pg'
+ * new PostgresDialect(new Pool(config))
+ * ```
  */
 export declare class PostgresDialect implements Dialect {
     #private;
-    constructor(config: PostgresDialectConfig);
+    constructor(configOrPool: PostgresDialectConfig | PostgresPool);
     /**
      * Creates a driver for the dialect.
      */

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

@@ -5,7 +5,6 @@ const postgres_driver_js_1 = require("./postgres-driver.js");
 const postgres_introspector_js_1 = require("./postgres-introspector.js");
 const postgres_query_compiler_js_1 = require("./postgres-query-compiler.js");
 const postgres_adapter_js_1 = require("./postgres-adapter.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -15,14 +14,21 @@ const object_utils_js_1 = require("../../util/object-utils.js");
  *
  * https://node-postgres.com/api/pool
  * https://node-postgres.com/api/client
+ *
+ * You can also provide an existing pg `Pool` instance:
+ *
+ * ```ts
+ * import { Pool } from 'pg'
+ * new PostgresDialect(new Pool(config))
+ * ```
  */
 class PostgresDialect {
-    #config;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
+    #configOrPool;
+    constructor(configOrPool) {
+        this.#configOrPool = configOrPool;
     }
     createDriver() {
-        return new postgres_driver_js_1.PostgresDriver(this.#config);
+        return new postgres_driver_js_1.PostgresDriver(this.#configOrPool);
     }
     createQueryCompiler() {
         return new postgres_query_compiler_js_1.PostgresQueryCompiler();

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

@@ -1,9 +1,11 @@
-import { DatabaseConnection } from '../../driver/database-connection.js';
+import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { PostgresDialectConfig } from './postgres-dialect-config.js';
+declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class PostgresDriver implements Driver {
     #private;
-    constructor(config: PostgresDialectConfig);
+    constructor(configOrPool: PostgresDialectConfig | PostgresPool);
     /**
      * Initializes the driver.
      *
@@ -35,9 +37,29 @@ 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>;
 }
+export interface PostgresPool {
+    connect(): Promise<PostgresPoolClient>;
+    end(): Promise<void>;
+}
+interface PostgresPoolClient {
+    query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
+    release(): void;
+}
+interface PostgresQueryResult<R> {
+    command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT';
+    rowCount: number;
+    rows: R[];
+}
+declare class PostgresConnection implements DatabaseConnection {
+    #private;
+    constructor(client: PostgresPoolClient);
+    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    [PRIVATE_RELEASE_METHOD](): void;
+}
+export {};

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

@@ -3,24 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDriver = void 0;
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const stack_trace_utils_js_1 = require("../../util/stack-trace-utils.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class PostgresDriver {
     #config;
     #connections = new WeakMap();
-    #pool = null;
-    constructor(config) {
-        this.#config = (0, object_utils_js_1.freeze)({ ...config });
+    #pool;
+    constructor(configOrPool) {
+        if (isPostgresPool(configOrPool)) {
+            this.#pool = configOrPool;
+        }
+        else {
+            this.#config = (0, object_utils_js_1.freeze)({ ...configOrPool });
+        }
     }
     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);
+        if (this.#config) {
+            // 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.
+            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);
+        }
     }
     async acquireConnection() {
         const client = await this.#pool.connect();
@@ -31,7 +37,7 @@ 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);
             }
         }
@@ -52,18 +58,20 @@ class PostgresDriver {
         await connection.executeQuery(compiled_query_js_1.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();
         }
     }
 }
 exports.PostgresDriver = PostgresDriver;
+function isPostgresPool(obj) {
+    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.connect) && (0, object_utils_js_1.isFunction)(obj.end);
+}
 async function importPgPool() {
     try {
         // The imported module name must be a string literal to make
@@ -87,18 +95,23 @@ class PostgresConnection {
         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 (0, stack_trace_utils_js_1.extendStackTrace)(err, new Error());
+        }
     }
     [PRIVATE_RELEASE_METHOD]() {
         this.#client.release();

package/dist/cjs/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/cjs/dialect/postgres/postgres-introspector.js

@@ -8,7 +8,15 @@ class PostgresIntrospector {
     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')
@@ -28,12 +36,15 @@ class PostgresIntrospector {
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('t.tablename', '!=', migrator_js_1.MIGRATION_TABLE)
-                .where('t.tablename', '!=', migrator_js_1.MIGRATION_LOCK_TABLE);
+                .where('t.tablename', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
+                .where('t.tablename', '!=', migrator_js_1.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/cjs/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>;
 }