kysely 0.23.3 → 0.23.5

package/dist/cjs/query-creator.d.ts

@@ -198,6 +198,8 @@ export declare class QueryCreator<DB> {
      *
      * ### Examples
      *
+     * Deleting person with id 1:
+     *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
@@ -206,7 +208,34 @@ export declare class QueryCreator<DB> {
      *
      * console.log(result.numDeletedRows)
      * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "person" where "person"."id" = $1
+     * ```
+     *
+     * Some databases such as MySQL support deleting from multiple tables:
+     *
+     * ```ts
+     * const result = await db
+     *   .deleteFrom(['person', 'pet'])
+     *   .using('person')
+     *   .innerJoin('pet', 'pet.owner_id', '=', 'person.id')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `person`, `pet`
+     * using `person`
+     * inner join `pet` on `pet`.`owner_id` = `person`.`id`
+     * where `person`.`id` = ?
+     * ```
      */
+    deleteFrom<TR extends TableReference<DB>>(tables: TR[]): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.

package/dist/cjs/query-creator.js

@@ -105,30 +105,11 @@ class QueryCreator {
             queryNode: insert_query_node_js_1.InsertQueryNode.create((0, table_parser_js_1.parseTable)(table), this.#props.withNode, true),
         });
     }
-    /**
-     * Creates a delete query.
-     *
-     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
-     * a where clause for the delete operation.
-     *
-     * The return value of the query is an instance of {@link DeleteResult}.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const result = await db
-     *   .deleteFrom('person')
-     *   .where('person.id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numDeletedRows)
-     * ```
-     */
-    deleteFrom(table) {
+    deleteFrom(tables) {
         return new delete_query_builder_js_1.DeleteQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.create((0, table_parser_js_1.parseTableExpression)(table), this.#props.withNode),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(tables), this.#props.withNode),
         });
     }
     /**

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -93,6 +93,10 @@ export declare class RawBuilder<O> implements Expression<O> {
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `RawBuilder` with a new output type.
      */
+    $castTo<T>(): RawBuilder<T>;
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
     castTo<T>(): RawBuilder<T>;
     /**
      * Adds a plugin for this SQL snippet.

package/dist/cjs/raw-builder/raw-builder.js

@@ -31,9 +31,15 @@ class RawBuilder {
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `RawBuilder` with a new output type.
      */
-    castTo() {
+    $castTo() {
         return new RawBuilder({ ...this.#props });
     }
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
+    castTo() {
+        return this.$castTo();
+    }
     /**
      * Adds a plugin for this SQL snippet.
      */
@@ -68,7 +74,7 @@ exports.RawBuilder = RawBuilder;
 function isRawBuilder(obj) {
     return ((0, object_utils_js_1.isObject)(obj) &&
         (0, object_utils_js_1.isFunction)(obj.as) &&
-        (0, object_utils_js_1.isFunction)(obj.castTo) &&
+        (0, object_utils_js_1.isFunction)(obj.$castTo) &&
         (0, object_utils_js_1.isFunction)(obj.withPlugin) &&
         (0, object_utils_js_1.isFunction)(obj.toOperationNode) &&
         (0, object_utils_js_1.isFunction)(obj.execute));

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

@@ -52,7 +52,11 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
     /**
      * Calls the given function passing `this` as the only argument.
      *
-     * See {@link CreateTableBuilder.call}
+     * See {@link CreateTableBuilder.$call}
+     */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
      */
     call<T>(func: (qb: this) => T): T;
 }

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

@@ -128,11 +128,17 @@ class AlterTableBuilder {
     /**
      * Calls the given function passing `this` as the only argument.
      *
-     * See {@link CreateTableBuilder.call}
+     * See {@link CreateTableBuilder.$call}
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
 }
 exports.AlterTableBuilder = AlterTableBuilder;
 class AlterTableColumnAlteringBuilder {

package/dist/cjs/schema/create-index-builder.d.ts

@@ -8,6 +8,12 @@ import { Expression } from '../expression/expression.js';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateIndexBuilderProps);
+    /**
+     * Adds the "if not exists" modifier.
+     *
+     * If the index already exists, no error is thrown if this method has been called.
+     */
+    ifNotExists(): CreateIndexBuilder;
     /**
      * Makes the index unique.
      */

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

@@ -13,6 +13,19 @@ class CreateIndexBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /**
+     * Adds the "if not exists" modifier.
+     *
+     * If the index already exists, no error is thrown if this method has been called.
+     */
+    ifNotExists() {
+        return new CreateIndexBuilder({
+            ...this.#props,
+            node: create_index_node_js_1.CreateIndexNode.cloneWith(this.#props.node, {
+                ifNotExists: true,
+            }),
+        });
+    }
     /**
      * Makes the index unique.
      */

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

@@ -211,7 +211,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```ts
      * db.schema
      *   .createTable('test')
-     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
@@ -231,10 +231,14 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      *
      * db.schema
      *   .createTable('test')
-     *   .call(addDefaultColumns)
+     *   .$call(addDefaultColumns)
      *   .execute()
      * ```
      */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
+     */
     call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;

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

@@ -278,7 +278,7 @@ class CreateTableBuilder {
      * ```ts
      * db.schema
      *   .createTable('test')
-     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
@@ -298,13 +298,19 @@ class CreateTableBuilder {
      *
      * db.schema
      *   .createTable('test')
-     *   .call(addDefaultColumns)
+     *   .$call(addDefaultColumns)
      *   .execute()
      * ```
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }

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

@@ -96,9 +96,22 @@ export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
  * Extracts the item type of an array.
  */
 export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+/**
+ * Any select query builder.
+ */
 export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
-export declare type SingleResultType<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O | undefined;
+export declare type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O> | undefined;
+export declare type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O>;
+export declare type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Represents a database row whose column names and their types are unknown.
+ */
 export declare type UnknownRow = Record<string, unknown>;
+/**
+ * Makes all properties of object type `T` nullable.
+ */
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
@@ -123,5 +136,11 @@ export declare type Nullable<T> = {
  * // { name: string, age: number, species?: 'cat' | 'dog' }
  */
 export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
+/**
+ * Evaluates to `true` if `T` is `never`.
+ */
 export declare type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
 export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;

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

@@ -7,7 +7,7 @@ export interface DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**
@@ -29,12 +29,14 @@ export interface SchemaMetadata {
 }
 export interface DatabaseMetadata {
     /**
-     * The tables found in the database.
+     * 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;
 }

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

@@ -25,12 +25,38 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * 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 MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `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 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
+     * {
+     *   async acquireMigrationLock(db, options): 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()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -26,19 +26,45 @@ export interface DialectAdapter {
      * 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 MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `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 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
+     * {
+     *   async acquireMigrationLock(db, options): 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()
+     *   }
+     * }
+     * ```
      *
      * 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>): Promise<void>;
+    acquireMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -47,5 +73,21 @@ export interface DialectAdapter {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(db: Kysely<any>): Promise<void>;
+    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;
 }

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

@@ -19,12 +19,38 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * 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 MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `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 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
+     * {
+     *   async acquireMigrationLock(db, options): 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()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -8,7 +8,7 @@ export declare class MysqlIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

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

@@ -11,30 +11,35 @@ export class MysqlIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('information_schema.schemata')
             .select('schema_name')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
-            .selectFrom('information_schema.columns')
+            .selectFrom('information_schema.columns as columns')
+            .innerJoin('information_schema.tables as tables', (b) => b
+            .onRef('columns.TABLE_CATALOG', '=', 'tables.TABLE_CATALOG')
+            .onRef('columns.TABLE_SCHEMA', '=', 'tables.TABLE_SCHEMA')
+            .onRef('columns.TABLE_NAME', '=', 'tables.TABLE_NAME'))
             .select([
-            'COLUMN_NAME',
-            'COLUMN_DEFAULT',
-            'TABLE_NAME',
-            'TABLE_SCHEMA',
-            'IS_NULLABLE',
-            'DATA_TYPE',
-            'EXTRA',
+            'columns.COLUMN_NAME',
+            'columns.COLUMN_DEFAULT',
+            'columns.TABLE_NAME',
+            'columns.TABLE_SCHEMA',
+            'tables.TABLE_TYPE',
+            'columns.IS_NULLABLE',
+            'columns.DATA_TYPE',
+            'columns.EXTRA',
         ])
-            .where('table_schema', '=', sql `database()`)
-            .orderBy('table_name')
-            .orderBy('ordinal_position')
-            .castTo();
+            .where('columns.TABLE_SCHEMA', '=', sql `database()`)
+            .orderBy('columns.TABLE_NAME')
+            .orderBy('columns.ORDINAL_POSITION')
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('table_name', '!=', DEFAULT_MIGRATION_TABLE)
-                .where('table_name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+                .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
@@ -50,6 +55,7 @@ export class MysqlIntrospector {
             if (!table) {
                 table = freeze({
                     name: it.TABLE_NAME,
+                    isView: it.TABLE_TYPE === 'VIEW',
                     schema: it.TABLE_SCHEMA,
                     columns: [],
                 });

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

@@ -19,12 +19,38 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * 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 MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `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 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
+     * {
+     *   async acquireMigrationLock(db, options): 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()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -8,7 +8,7 @@ export declare class PostgresIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

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

@@ -11,7 +11,7 @@ export class PostgresIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('pg_catalog.pg_namespace')
             .select('nspname')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.nspname }));
     }
@@ -32,6 +32,7 @@ export class PostgresIntrospector {
             'a.attnotnull as not_null',
             'a.atthasdef as has_default',
             'c.relname as table',
+            'c.relkind as table_type',
             'ns.nspname as schema',
             'typ.typname as type',
             'dtns.nspname as type_schema',
@@ -47,7 +48,7 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where('c.relkind', '=', 'r')
+            .where('c.relkind', 'in', ['r', 'v'])
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns
@@ -56,7 +57,7 @@ export class PostgresIntrospector {
             .orderBy('ns.nspname')
             .orderBy('c.relname')
             .orderBy('a.attnum')
-            .castTo();
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
@@ -76,6 +77,7 @@ export class PostgresIntrospector {
             if (!table) {
                 table = freeze({
                     name: it.table,
+                    isView: it.table_type === 'v',
                     schema: it.schema,
                     columns: [],
                 });