kysely 0.27.3 → 0.27.5

package/dist/esm/operation-node/insert-query-node.d.ts

@@ -3,6 +3,7 @@ import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
+import { OutputNode } from './output-node.js';
 import { ReturningNode } from './returning-node.js';
 import { TableNode } from './table-node.js';
 import { TopNode } from './top-node.js';
@@ -21,7 +22,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal

package/dist/esm/operation-node/merge-query-node.d.ts

@@ -1,6 +1,7 @@
 import { AliasNode } from './alias-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
+import { OutputNode } from './output-node.js';
 import { TableNode } from './table-node.js';
 import { TopNode } from './top-node.js';
 import { WhenNode } from './when-node.js';
@@ -12,6 +13,8 @@ export interface MergeQueryNode extends OperationNode {
     readonly whens?: ReadonlyArray<WhenNode>;
     readonly with?: WithNode;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal

package/dist/esm/operation-node/on-node.d.ts

@@ -9,5 +9,5 @@ export interface OnNode extends OperationNode {
 export declare const OnNode: Readonly<{
     is(node: OperationNode): node is OnNode;
     create(filter: OperationNode): OnNode;
-    cloneWithOperation(onNode: OnNode, operator: 'And' | 'Or', operation: OperationNode): OnNode;
+    cloneWithOperation(onNode: OnNode, operator: "And" | "Or", operation: OperationNode): OnNode;
 }>;

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -91,6 +91,7 @@ import { AddIndexNode } from './add-index-node.js';
 import { CastNode } from './cast-node.js';
 import { FetchNode } from './fetch-node.js';
 import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -105,9 +106,12 @@ import { TopNode } from './top-node.js';
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -117,7 +121,10 @@ import { TopNode } from './top-node.js';
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 export declare class OperationNodeTransformer {
@@ -211,6 +218,7 @@ export declare class OperationNodeTransformer {
     protected transformCast(node: CastNode): CastNode;
     protected transformFetch(node: FetchNode): FetchNode;
     protected transformTop(node: TopNode): TopNode;
+    protected transformOutput(node: OutputNode): OutputNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -15,9 +15,12 @@ import { requireAllProps } from '../util/require-all-props.js';
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -27,7 +30,10 @@ import { requireAllProps } from '../util/require-all-props.js';
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 export class OperationNodeTransformer {
@@ -125,6 +131,7 @@ export class OperationNodeTransformer {
         CastNode: this.transformCast.bind(this),
         FetchNode: this.transformFetch.bind(this),
         TopNode: this.transformTop.bind(this),
+        OutputNode: this.transformOutput.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -260,12 +267,14 @@ export class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             ignore: node.ignore,
             replace: node.replace,
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformValues(node) {
@@ -282,11 +291,13 @@ export class OperationNodeTransformer {
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
             explain: this.transformNode(node.explain),
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformReturning(node) {
@@ -327,6 +338,7 @@ export class OperationNodeTransformer {
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
             identity: node.identity,
+            ifNotExists: node.ifNotExists,
         });
     }
     transformAddColumn(node) {
@@ -377,10 +389,12 @@ export class OperationNodeTransformer {
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             explain: this.transformNode(node.explain),
             limit: this.transformNode(node.limit),
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformColumnUpdate(node) {
@@ -682,6 +696,7 @@ export class OperationNodeTransformer {
             kind: 'AggregateFunctionNode',
             aggregated: this.transformNodeList(node.aggregated),
             distinct: node.distinct,
+            orderBy: this.transformNode(node.orderBy),
             filter: this.transformNode(node.filter),
             func: node.func,
             over: this.transformNode(node.over),
@@ -792,6 +807,8 @@ export class OperationNodeTransformer {
             whens: this.transformNodeList(node.whens),
             with: this.transformNode(node.with),
             top: this.transformNode(node.top),
+            endModifiers: this.transformNodeList(node.endModifiers),
+            output: this.transformNode(node.output),
         });
     }
     transformMatched(node) {
@@ -832,6 +849,12 @@ export class OperationNodeTransformer {
             modifiers: node.modifiers,
         });
     }
+    transformOutput(node) {
+        return requireAllProps({
+            kind: 'OutputNode',
+            selections: this.transformNodeList(node.selections),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -91,6 +91,7 @@ import { AddIndexNode } from './add-index-node.js';
 import { CastNode } from './cast-node.js';
 import { FetchNode } from './fetch-node.js';
 import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -188,4 +189,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitCast(node: CastNode): void;
     protected abstract visitFetch(node: FetchNode): void;
     protected abstract visitTop(node: TopNode): void;
+    protected abstract visitOutput(node: OutputNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -98,6 +98,7 @@ export class OperationNodeVisitor {
         CastNode: this.visitCast.bind(this),
         FetchNode: this.visitFetch.bind(this),
         TopNode: this.visitTop.bind(this),
+        OutputNode: this.visitOutput.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode';
+export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode' | 'OutputNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/operator-node.d.ts

@@ -1,11 +1,11 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
 export declare const JSON_OPERATORS: readonly ["->", "->>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare const UNARY_OPERATORS: readonly ["not", "-", "exists", "not exists"];
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
 export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
 export type JSONOperator = (typeof JSON_OPERATORS)[number];

package/dist/esm/operation-node/operator-node.js

@@ -20,9 +20,11 @@ export const COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '^@',
     '&&',
     '?',
     '?&',
+    '?|',
     '!<',
     '!>',
     '<=>',

package/dist/esm/operation-node/output-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface OutputNode extends OperationNode {
+    readonly kind: 'OutputNode';
+    readonly selections: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const OutputNode: Readonly<{
+    is(node: OperationNode): node is OutputNode;
+    create(selections: ReadonlyArray<OperationNode>): OutputNode;
+    cloneWithSelections(output: OutputNode, selections: ReadonlyArray<OperationNode>): OutputNode;
+}>;

package/dist/esm/operation-node/output-node.js

@@ -0,0 +1,24 @@
+/// <reference types="./output-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const OutputNode = freeze({
+    is(node) {
+        return node.kind === 'OutputNode';
+    },
+    create(selections) {
+        return freeze({
+            kind: 'OutputNode',
+            selections: freeze(selections),
+        });
+    },
+    cloneWithSelections(output, selections) {
+        return freeze({
+            ...output,
+            selections: output.selections
+                ? freeze([...output.selections, ...selections])
+                : freeze(selections),
+        });
+    },
+});

package/dist/esm/operation-node/query-node.d.ts

@@ -12,6 +12,7 @@ import { ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
 import { MergeQueryNode } from './merge-query-node.js';
 import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
@@ -28,17 +29,25 @@ type HasExplain = {
 type HasTop = {
     top?: TopNode;
 };
+type HasOutput = {
+    output?: OutputNode;
+};
+type HasEndModifiers = {
+    endModifiers?: ReadonlyArray<OperationNode>;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
+    cloneWithEndModifier<T extends HasEndModifiers>(node: T, modifier: OperationNode): T;
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
-    cloneWithJoin<T_1 extends HasJoins>(node: T_1, join: JoinNode): T_1;
-    cloneWithReturning<T_2 extends HasReturning>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
-    cloneWithoutReturning<T_3 extends HasReturning>(node: T_3): T_3;
-    cloneWithoutWhere<T_4 extends HasWhere>(node: T_4): T_4;
-    cloneWithExplain<T_5 extends HasExplain>(node: T_5, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_5;
-    cloneWithTop<T_6 extends HasTop>(node: T_6, top: TopNode): T_6;
+    cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): T;
+    cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): T;
+    cloneWithoutReturning<T extends HasReturning>(node: T): T;
+    cloneWithoutWhere<T extends HasWhere>(node: T): T;
+    cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): T;
+    cloneWithTop<T extends HasTop>(node: T, top: TopNode): T;
+    cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): T;
 }>;
 export {};

package/dist/esm/operation-node/query-node.js

@@ -8,6 +8,7 @@ import { freeze } from '../util/object-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { ExplainNode } from './explain-node.js';
 import { MergeQueryNode } from './merge-query-node.js';
+import { OutputNode } from './output-node.js';
 /**
  * @internal
  */
@@ -19,6 +20,14 @@ export const QueryNode = freeze({
             DeleteQueryNode.is(node) ||
             MergeQueryNode.is(node));
     },
+    cloneWithEndModifier(node, modifier) {
+        return freeze({
+            ...node,
+            endModifiers: node.endModifiers
+                ? freeze([...node.endModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
     cloneWithWhere(node, operation) {
         return freeze({
             ...node,
@@ -65,4 +74,12 @@ export const QueryNode = freeze({
             top,
         });
     },
+    cloneWithOutput(node, selections) {
+        return freeze({
+            ...node,
+            output: node.output
+                ? OutputNode.cloneWithSelections(node.output, selections)
+                : OutputNode.create(selections),
+        });
+    },
 });

package/dist/esm/operation-node/select-query-node.d.ts

@@ -46,7 +46,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
-    cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItems(selectNode: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
@@ -58,4 +57,5 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -48,14 +48,6 @@ export const SelectQueryNode = freeze({
                 : freeze([modifier]),
         });
     },
-    cloneWithEndModifier(select, modifier) {
-        return freeze({
-            ...select,
-            endModifiers: select.endModifiers
-                ? freeze([...select.endModifiers, modifier])
-                : freeze([modifier]),
-        });
-    },
     cloneWithOrderByItems(selectNode, items) {
         return freeze({
             ...selectNode,
@@ -130,4 +122,10 @@ export const SelectQueryNode = freeze({
             orderBy: undefined,
         });
     },
+    cloneWithoutGroupBy(select) {
+        return freeze({
+            ...select,
+            groupBy: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/update-query-node.d.ts

@@ -10,6 +10,7 @@ import { FromNode } from './from-node.js';
 import { ExplainNode } from './explain-node.js';
 import { LimitNode } from './limit-node.js';
 import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
@@ -21,8 +22,10 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
     readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly limit?: LimitNode;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal

package/dist/esm/operation-node/where-node.d.ts

@@ -9,5 +9,5 @@ export interface WhereNode extends OperationNode {
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
     create(filter: OperationNode): WhereNode;
-    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): WhereNode;
+    cloneWithOperation(whereNode: WhereNode, operator: "And" | "Or", operation: OperationNode): WhereNode;
 }>;

package/dist/esm/parser/returning-parser.d.ts

@@ -1,7 +1,8 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
+import { MergeResult } from '../query-builder/merge-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection, AllSelection, CallbackSelection } from './select-parser.js';
-export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
-export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult ? CallbackSelection<DB, TB, CB> : O extends DeleteResult ? CallbackSelection<DB, TB, CB> : O extends UpdateResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
-export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;
+export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
+export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

package/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -35,47 +35,48 @@ export interface CamelCasePluginOptions {
 }
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *
@@ -88,11 +89,15 @@ export interface CamelCasePluginOptions {
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```
@@ -111,19 +116,41 @@ export declare class CamelCasePlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`