kysely 0.17.3 → 0.19.0

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -19,7 +19,7 @@ import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
-export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -206,9 +206,9 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, TB, O>;
-    where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
-    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -260,7 +260,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -324,15 +324,15 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, TB, O>;
-    orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
-    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(grouper: WhereGrouper<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    orWhere(raw: AnyRawBuilder): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -393,19 +393,48 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * )
      * ```
      */
-    whereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `not exists` clause.
      */
-    whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    whereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `or exists` clause.
      */
-    orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Just like {@link whereExists} but creates a `or not exists` clause.
      */
-    orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    orWhereNotExists(arg: ExistsExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Adds a from clause to the update query.
+     *
+     * This is supported only on some databases like PostgreSQL.
+     *
+     * The API is the same as {@link QueryCreator.selectFrom}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .from('pet')
+     *   .set({
+     *     first_name: (eb) => eb.ref('pet.name')
+     *   })
+     *   .whereRef('pet.owner_id', '=', 'person.id')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = "pet"."name"
+     * from "pet"
+     * where "pet"."owner_id" = "person"."id"
+     * ```
+     */
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -515,23 +544,23 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a left join nstead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -619,7 +648,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * where "id" = $4
      * ```
      */
-    set(row: MutationObject<DB, TB>): UpdateQueryBuilder<DB, TB, O>;
+    set(row: MutationObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -679,13 +708,13 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .executeTakeFirst()
      * ```
      */
-    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
-    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): UpdateQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    returningAll(): UpdateQueryBuilder<DB, UT, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -745,18 +774,18 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }
      * ```
      */
-    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, TB, O2>): UpdateQueryBuilder<DB, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
+    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): UpdateQueryBuilder<DB, UT, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
-    castTo<T>(): UpdateQueryBuilder<DB, TB, T>;
+    castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
     /**
      * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
      */
-    withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, TB, O>;
+    withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, UT, TB, O>;
     toOperationNode(): UpdateQueryNode;
     compile(): CompiledQuery;
     /**

package/dist/cjs/query-builder/update-query-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateQueryBuilder = void 0;
 const join_parser_js_1 = require("../parser/join-parser.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const filter_parser_js_1 = require("../parser/filter-parser.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
@@ -64,6 +65,12 @@ class UpdateQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
         });
     }
+    from(from) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, (0, table_parser_js_1.parseTableExpressionOrList)(from)),
+        });
+    }
     innerJoin(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,

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

@@ -427,6 +427,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         if (node.updates) {
             this.compileList(node.updates);
         }
+        if (node.from) {
+            this.append(' ');
+            this.visitNode(node.from);
+        }
         if (node.joins) {
             this.append(' ');
             this.compileList(node.joins, ' ');

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

@@ -9,6 +9,7 @@ import { WithNode } from './operation-node/with-node.js';
 import { InsertResult } from './query-builder/insert-result.js';
 import { DeleteResult } from './query-builder/delete-result.js';
 import { UpdateResult } from './query-builder/update-result.js';
+import { KyselyPlugin } from './plugin/kysely-plugin.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -203,7 +204,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *
@@ -252,6 +253,14 @@ export declare class QueryCreator<DB> {
      * See the {@link with} method for examples and more documentation.
      */
     withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    /**
+     * Returns a copy of this query creator instance with the given plugin installed.
+     */
+    withPlugin(plugin: KyselyPlugin): QueryCreator<DB>;
+    /**
+     * Returns a copy of this query creator instance without any plugins.
+     */
+    withoutPlugins(): QueryCreator<DB>;
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

package/dist/cjs/query-creator.js

@@ -192,6 +192,24 @@ class QueryCreator {
                 : with_node_js_1.WithNode.create(cte, { recursive: true }),
         });
     }
+    /**
+     * Returns a copy of this query creator instance with the given plugin installed.
+     */
+    withPlugin(plugin) {
+        return new QueryCreator({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
+    /**
+     * Returns a copy of this query creator instance without any plugins.
+     */
+    withoutPlugins() {
+        return new QueryCreator({
+            ...this.#props,
+            executor: this.#props.executor.withoutPlugins(),
+        });
+    }
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

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

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -38,8 +39,37 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * select concat(first_name, ' ', last_name) as "full_name"
      * from "person"
      * ```
+     *
+     * You can also pass in a raw SQL snippet but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    as<A extends string = never>(alias: AnyRawBuilder): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -67,9 +97,9 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
      * which causes this type to be equal to AliasedRawBuilder with any A
      * as long as O is the same.
      */
-    protected get alias(): A;
+    protected get alias(): A | AnyRawBuilder;
     toOperationNode(): AliasNode;
-    constructor(rawBuilder: RawBuilder<O>, alias: A);
+    constructor(rawBuilder: RawBuilder<O>, alias: A | AnyRawBuilder);
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;

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

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasedRawBuilder = exports.RawBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -16,31 +18,6 @@ class RawBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
-    /**
-     * Returns an aliased version of the SQL expression.
-     *
-     * In addition to slapping `as "the_alias"` to the end of the SQL,
-     * this method also provides strict typing:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select(
-     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     *
-     * // `full_name: string` field exists in the result type.
-     * console.log(result.full_name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```ts
-     * select concat(first_name, ' ', last_name) as "full_name"
-     * from "person"
-     * ```
-     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -103,7 +80,9 @@ class AliasedRawBuilder {
         return this.#alias;
     }
     toOperationNode() {
-        return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), this.#alias);
+        return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
+            ? this.#alias.toOperationNode()
+            : identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;

package/dist/cjs/schema/schema.d.ts

@@ -8,6 +8,7 @@ import { DropSchemaBuilder } from './drop-schema-builder.js';
 import { DropTableBuilder } from './drop-table-builder.js';
 import { CreateViewBuilder } from './create-view-builder.js';
 import { DropViewBuilder } from './drop-view-builder.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 /**
  * Provides methods for building database schema.
  */
@@ -169,6 +170,14 @@ export declare class SchemaModule {
      * ```
      */
     dropView(viewName: string): DropViewBuilder;
+    /**
+     * Returns a copy of this schema module with the given plugin installed.
+     */
+    withPlugin(plugin: KyselyPlugin): SchemaModule;
+    /**
+     * Returns a copy of this schema module  without any plugins.
+     */
+    withoutPlugins(): SchemaModule;
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/cjs/schema/schema.js

@@ -239,6 +239,18 @@ class SchemaModule {
             dropViewNode: drop_view_node_js_1.DropViewNode.create(viewName),
         });
     }
+    /**
+     * Returns a copy of this schema module with the given plugin installed.
+     */
+    withPlugin(plugin) {
+        return new SchemaModule(this.#executor.withPlugin(plugin));
+    }
+    /**
+     * Returns a copy of this schema module  without any plugins.
+     */
+    withoutPlugins() {
+        return new SchemaModule(this.#executor.withoutPlugins());
+    }
     /**
      * See {@link QueryCreator.withSchema}
      */

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

@@ -43,13 +43,21 @@ export declare type ColumnType<SelectType, InsertType = SelectType, UpdateType =
  * is the same for all selects, inserts and updates but the
  * column is optional for inserts and updates.
  *
- * This is implemented using {@link ColumnType} like this:
+ * The implementation:
  *
  * ```ts
+ * // The update type is `S` instead of `S | undefined` because
+ * // updates are always optional --> no need to specify optionality.
  * type Generated<S> = ColumnType<S, S | undefined, S>
  * ```
  */
 export declare type Generated<S> = ColumnType<S, S | undefined, S>;
+/**
+ * A shortcut for defining columns that are only database-generated
+ * (like postgres GENERATED ALWAYS AS IDENTITY). No insert/update
+ * is allowed.
+ */
+export declare type GeneratedAlways<S> = ColumnType<S, never, never>;
 /**
  * Evaluates to `K` if `T` can be `null` or `undefined`.
  */

package/dist/cjs/util/stack-trace-utils.d.ts

@@ -0,0 +1 @@
+export declare function extendStackTrace(err: unknown, stackError: Error): unknown;

package/dist/cjs/util/stack-trace-utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendStackTrace = void 0;
+const object_utils_js_1 = require("./object-utils.js");
+function extendStackTrace(err, stackError) {
+    if (isStackHolder(err) && stackError.stack) {
+        // Remove the first line that just says `Error`.
+        const stackExtension = stackError.stack.split('\n').slice(1).join('\n');
+        err.stack += `\n${stackExtension}`;
+        return err;
+    }
+    return err;
+}
+exports.extendStackTrace = extendStackTrace;
+function isStackHolder(obj) {
+    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isString)(obj.stack);
+}

package/dist/esm/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.