kysely 0.17.2 → 0.18.1

package/dist/esm/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/esm/query-builder/update-query-builder.js

@@ -1,5 +1,6 @@
 /// <reference types="./update-query-builder.d.ts" />
 import { parseJoin, } from '../parser/join-parser.js';
+import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
@@ -62,6 +63,12 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(arg)),
         });
     }
+    from(from) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, parseTableExpressionOrList(from)),
+        });
+    }
     innerJoin(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,

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

@@ -425,6 +425,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         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/esm/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/esm/query-creator.js

@@ -190,6 +190,24 @@ export class QueryCreator {
                 : 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/esm/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/esm/raw-builder/raw-builder.js

@@ -1,8 +1,10 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -14,31 +16,6 @@ export class RawBuilder {
     constructor(props) {
         this.#props = 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);
     }
@@ -100,7 +77,9 @@ export class AliasedRawBuilder {
         return this.#alias;
     }
     toOperationNode() {
-        return AliasNode.create(this.#rawBuilder.toOperationNode(), this.#alias);
+        return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias)
+            ? this.#alias.toOperationNode()
+            : IdentifierNode.create(this.#alias));
     }
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;

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

@@ -237,6 +237,18 @@ export class SchemaModule {
             dropViewNode: 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/esm/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/esm/util/stack-trace-utils.d.ts

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

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

@@ -0,0 +1,14 @@
+/// <reference types="./stack-trace-utils.d.ts" />
+import { isObject, isString } from './object-utils.js';
+export 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;
+}
+function isStackHolder(obj) {
+    return isObject(obj) && isString(obj.stack);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.17.2",
+  "version": "0.18.1",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -48,21 +48,21 @@
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.5.0",
-    "@types/chai": "^4.3.0",
+    "@types/chai": "^4.3.1",
     "@types/chai-subset": "^1.3.3",
     "@types/mocha": "^9.1.0",
     "@types/pg": "^8.6.5",
-    "better-sqlite3": "^7.5.0",
+    "better-sqlite3": "^7.5.1",
     "chai": "^4.3.6",
     "chai-subset": "^1.6.0",
-    "esbuild": "^0.14.27",
+    "esbuild": "^0.14.36",
     "mocha": "^9.2.2",
     "mysql2": "^2.3.3",
     "pg": "^8.7.3",
-    "playwright": "^1.20.0",
-    "prettier": "^2.6.0",
-    "tsd": "^0.19.1",
-    "typedoc": "^0.22.13",
-    "typescript": "4.6.2"
+    "playwright": "^1.21.0",
+    "prettier": "^2.6.2",
+    "tsd": "^0.20.0",
+    "typedoc": "^0.22.15",
+    "typescript": "4.6.3"
   }
 }