kysely 0.10.0 → 0.11.2

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

@@ -60,6 +60,9 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { OnNode } from './on-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -149,6 +152,9 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
+    protected transformOn(node: OnNode): OnNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -33,7 +33,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
  */
 class OperationNodeTransformer {
     nodeStack = [];
-    #transformers = {
+    #transformers = (0, object_utils_js_1.freeze)({
         AliasNode: this.transformAlias.bind(this),
         ColumnNode: this.transformColumn.bind(this),
         IdentifierNode: this.transformIdentifier.bind(this),
@@ -95,7 +95,10 @@ class OperationNodeTransformer {
         UnionNode: this.transformUnion.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
-    };
+        GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.transformDefaultValue.bind(this),
+        OnNode: this.transformOn.bind(this),
+    });
     transformNode = (node) => {
         if (!node) {
             return undefined;
@@ -274,6 +277,7 @@ class OperationNodeTransformer {
             nullable: node.nullable,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
+            generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
         };
     }
     transformAddColumn(node) {
@@ -525,6 +529,7 @@ class OperationNodeTransformer {
             kind: 'CreateViewNode',
             name: this.transformNode(node.name),
             orReplace: node.orReplace,
+            ifNotExists: node.ifNotExists,
             materialized: node.materialized,
             columns: this.transformNodeList(node.columns),
             as: this.transformNode(node.as),
@@ -538,6 +543,25 @@ class OperationNodeTransformer {
             materialized: node.materialized,
         };
     }
+    transformGeneratedAlwaysAs(node) {
+        return {
+            kind: 'GeneratedAlwaysAsNode',
+            expression: this.transformNode(node.expression),
+            stored: node.stored,
+        };
+    }
+    transformDefaultValue(node) {
+        return {
+            kind: 'DefaultValueNode',
+            defaultValue: this.transformNode(node.defaultValue),
+        };
+    }
+    transformOn(node) {
+        return {
+            kind: 'OnNode',
+            on: this.transformNode(node.on),
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/cjs/operation-node/operation-node-utils.d.ts

@@ -14,4 +14,4 @@ import { ValueNode } from './value-node.js';
 export declare type ReferenceExpressionNode = ColumnNode | ReferenceNode | SelectQueryNode | RawNode;
 export declare type ValueExpressionNode = ValueNode | ValueListNode | PrimitiveValueListNode | ReferenceExpressionNode;
 export declare type TableExpressionNode = TableNode | AliasNode;
-export declare type FilterExpressionNode = FilterNode | AndNode | OrNode | ParensNode;
+export declare type FilterExpressionNode = FilterNode | AndNode | OrNode | ParensNode | RawNode;

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

@@ -60,9 +60,13 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { OnNode } from './on-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
+    protected get parentNode(): OperationNode | undefined;
     protected readonly visitNode: (node: OperationNode) => void;
     protected abstract visitSelectQuery(node: SelectQueryNode): void;
     protected abstract visitSelection(node: SelectionNode): void;
@@ -125,4 +129,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;
+    protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected abstract visitDefaultValue(node: DefaultValueNode): void;
+    protected abstract visitOn(node: OnNode): void;
 }

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

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationNodeVisitor = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
 class OperationNodeVisitor {
     nodeStack = [];
-    #visitors = {
+    get parentNode() {
+        return this.nodeStack[this.nodeStack.length - 2];
+    }
+    #visitors = (0, object_utils_js_1.freeze)({
         AliasNode: this.visitAlias.bind(this),
         ColumnNode: this.visitColumn.bind(this),
         IdentifierNode: this.visitIdentifier.bind(this),
@@ -65,7 +69,10 @@ class OperationNodeVisitor {
         UnionNode: this.visitUnion.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
-    };
+        GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.visitDefaultValue.bind(this),
+        OnNode: this.visitOn.bind(this),
+    });
     visitNode = (node) => {
         this.nodeStack.push(node);
         this.#visitors[node.kind](node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -2,10 +2,10 @@ import { InsertQueryNode } from './insert-query-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { UpdateQueryNode } from './update-query-node.js';
 import { DeleteQueryNode } from './delete-query-node.js';
-import { WhereChildNode } from './where-node.js';
 import { JoinNode } from './join-node.js';
 import { SelectionNode } from './selection-node.js';
 import { OperationNode } from './operation-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 export declare type QueryNode = SelectQueryNode | DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type MutatingQueryNode = DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | UpdateQueryNode;
@@ -16,8 +16,8 @@ export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     isMutating(node: OperationNode): node is MutatingQueryNode;
     isFilterable(node: OperationNode): node is FilterableQueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: WhereChildNode): T;
-    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: WhereChildNode): T_1;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
     cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

package/dist/cjs/operation-node/raw-node.d.ts

@@ -9,6 +9,6 @@ export interface RawNode extends OperationNode {
  */
 export declare const RawNode: Readonly<{
     is(node: OperationNode): node is RawNode;
-    create(sqlFragments: string[], params: ReadonlyArray<OperationNode>): RawNode;
+    create(sqlFragments: ReadonlyArray<string>, params: ReadonlyArray<OperationNode>): RawNode;
     createWithSql(sql: string): RawNode;
 }>;

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

@@ -1,12 +1,12 @@
 import { FromNode } from './from-node.js';
 import { GroupByItemNode } from './group-by-item-node.js';
 import { GroupByNode } from './group-by-node.js';
-import { HavingNode, HavingNodeChild } from './having-node.js';
+import { HavingNode } from './having-node.js';
 import { JoinNode } from './join-node.js';
 import { LimitNode } from './limit-node.js';
 import { OffsetNode } from './offset-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
+import { FilterExpressionNode, TableExpressionNode } from './operation-node-utils.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
@@ -44,8 +44,8 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;

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

@@ -1,18 +1,14 @@
-import { AndNode } from './and-node.js';
-import { FilterNode } from './filter-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
-export declare type WhereChildNode = FilterNode | AndNode | OrNode | ParensNode;
 export interface WhereNode extends OperationNode {
     readonly kind: 'WhereNode';
-    readonly where: WhereChildNode;
+    readonly where: FilterExpressionNode;
 }
 /**
  * @internal
  */
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
-    create(filter: WhereChildNode): WhereNode;
-    cloneWithFilter(whereNode: WhereNode, op: 'And' | 'Or', where: WhereChildNode): WhereNode;
+    create(filter: FilterExpressionNode): WhereNode;
+    cloneWithFilter(whereNode: WhereNode, op: 'And' | 'Or', filter: FilterExpressionNode): WhereNode;
 }>;

package/dist/cjs/operation-node/where-node.js

@@ -17,12 +17,12 @@ exports.WhereNode = (0, object_utils_js_1.freeze)({
             where: filter,
         });
     },
-    cloneWithFilter(whereNode, op, where) {
+    cloneWithFilter(whereNode, op, filter) {
         return (0, object_utils_js_1.freeze)({
             ...whereNode,
             where: op === 'And'
-                ? and_node_js_1.AndNode.create(whereNode.where, where)
-                : or_node_js_1.OrNode.create(whereNode.where, where),
+                ? and_node_js_1.AndNode.create(whereNode.where, filter)
+                : or_node_js_1.OrNode.create(whereNode.where, filter),
         });
     },
 });

package/dist/cjs/parser/filter-parser.d.ts

@@ -12,3 +12,4 @@ export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExp
 export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
 export declare function parseExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
 export declare function parseNotExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
+export declare function parseFilter(ctx: ParseContext, type: 'where' | 'having' | 'on', args: any[]): FilterExpressionNode;

package/dist/cjs/parser/filter-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNotExistFilter = exports.parseExistFilter = exports.parseReferenceFilter = exports.parseOnFilter = exports.parseHavingFilter = exports.parseWhereFilter = void 0;
+exports.parseFilter = exports.parseNotExistFilter = exports.parseExistFilter = exports.parseReferenceFilter = exports.parseOnFilter = exports.parseHavingFilter = exports.parseWhereFilter = void 0;
 const filter_node_js_1 = require("../operation-node/filter-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
@@ -12,39 +12,15 @@ const value_parser_js_1 = require("./value-parser.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 function parseWhereFilter(ctx, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
-    }
-    else if (args.length === 1 && (0, object_utils_js_1.isFunction)(args[0])) {
-        return parseWhereGroup(ctx, args[0]);
-    }
-    else {
-        throw new Error(`invalid arguments passed to a where method ${JSON.stringify(args)}`);
-    }
+    return parseFilter(ctx, 'where', args);
 }
 exports.parseWhereFilter = parseWhereFilter;
 function parseHavingFilter(ctx, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
-    }
-    else if (args.length === 1 && (0, object_utils_js_1.isFunction)(args[0])) {
-        return parseHavingGroup(ctx, args[0]);
-    }
-    else {
-        throw new Error(`invalid arguments passed to a having method ${JSON.stringify(args)}`);
-    }
+    return parseFilter(ctx, 'having', args);
 }
 exports.parseHavingFilter = parseHavingFilter;
 function parseOnFilter(ctx, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
-    }
-    else if (args.length === 1 && (0, object_utils_js_1.isFunction)(args[0])) {
-        return parseOnGroup(ctx, args[0]);
-    }
-    else {
-        throw new Error(`invalid arguments passed to an on method ${JSON.stringify(args)}`);
-    }
+    return parseFilter(ctx, 'on', args);
 }
 exports.parseOnFilter = parseOnFilter;
 function parseReferenceFilter(ctx, lhs, op, rhs) {
@@ -59,6 +35,25 @@ function parseNotExistFilter(ctx, arg) {
     return parseExistExpression(ctx, 'not exists', arg);
 }
 exports.parseNotExistFilter = parseNotExistFilter;
+function parseFilter(ctx, type, args) {
+    if (args.length === 3) {
+        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
+    }
+    else if (args.length === 1) {
+        const arg = args[0];
+        if ((0, object_utils_js_1.isFunction)(arg)) {
+            return GROUP_PARSERS[type](ctx, arg);
+        }
+        else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
+            const node = arg.toOperationNode();
+            if (raw_node_js_1.RawNode.is(node)) {
+                return node;
+            }
+        }
+    }
+    throw new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+}
+exports.parseFilter = parseFilter;
 function parseThreeArgFilter(ctx, left, op, right) {
     if ((op === 'is' || op === 'is not') && ((0, object_utils_js_1.isNull)(right) || (0, object_utils_js_1.isBoolean)(right))) {
         return parseIsFilter(ctx, left, op, right);
@@ -79,30 +74,6 @@ function parseFilterOperator(op) {
     }
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
-function parseWhereGroup(ctx, callback) {
-    const query = callback(ctx.createSelectQueryBuilder([]));
-    const queryNode = query.toOperationNode();
-    if (!queryNode.where) {
-        throw new Error('no `where*` methods called insided a group callback');
-    }
-    return parens_node_js_1.ParensNode.create(queryNode.where.where);
-}
-function parseHavingGroup(ctx, callback) {
-    const query = callback(ctx.createSelectQueryBuilder([]));
-    const queryNode = query.toOperationNode();
-    if (!queryNode.having) {
-        throw new Error('no `having*` methods called insided a group callback');
-    }
-    return parens_node_js_1.ParensNode.create(queryNode.having.having);
-}
-function parseOnGroup(ctx, callback) {
-    const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
-    const joinNode = joinBuilder.toOperationNode();
-    if (!joinNode.on) {
-        throw new Error('no `on*` methods called insided a group callback');
-    }
-    return parens_node_js_1.ParensNode.create(joinNode.on);
-}
 function parseExistExpression(ctx, type, arg) {
     const node = (0, object_utils_js_1.isFunction)(arg)
         ? arg(ctx.createExpressionBuilder()).toOperationNode()
@@ -112,3 +83,29 @@ function parseExistExpression(ctx, type, arg) {
     }
     return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), node);
 }
+const GROUP_PARSERS = (0, object_utils_js_1.freeze)({
+    where(ctx, callback) {
+        const query = callback(ctx.createSelectQueryBuilder([]));
+        const queryNode = query.toOperationNode();
+        if (!queryNode.where) {
+            throw new Error('no `where` methods called insided a group callback');
+        }
+        return parens_node_js_1.ParensNode.create(queryNode.where.where);
+    },
+    having(ctx, callback) {
+        const query = callback(ctx.createSelectQueryBuilder([]));
+        const queryNode = query.toOperationNode();
+        if (!queryNode.having) {
+            throw new Error('no `having` methods called insided a group callback');
+        }
+        return parens_node_js_1.ParensNode.create(queryNode.having.having);
+    },
+    on(ctx, callback) {
+        const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
+        const joinNode = joinBuilder.toOperationNode();
+        if (!joinNode.on) {
+            throw new Error('no `on` methods called insided a group callback');
+        }
+        return parens_node_js_1.ParensNode.create(joinNode.on.on);
+    },
+});

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

@@ -1,7 +1,9 @@
+import { DeleteResult } from '../query-builder/delete-result.js';
+import { InsertResult } from '../query-builder/insert-result.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
-import { DeleteResultTypeTag, InsertResultTypeTag, UpdateResultTypeTag } from '../util/type-utils.js';
+import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection } from './select-parser.js';
 /**
  * `returning` method output query builder type
  */
-export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? Selection<DB, TB, S> : O extends DeleteResultTypeTag ? Selection<DB, TB, S> : O extends UpdateResultTypeTag ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;
+export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResult ? Selection<DB, TB, S> : O extends DeleteResult ? Selection<DB, TB, S> : O extends UpdateResult ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;

package/dist/cjs/parser/select-parser.d.ts

@@ -1,7 +1,7 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../util/type-utils.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.js';
 /**
@@ -13,7 +13,7 @@ export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpr
  * Given a selection expression returns a query builder type that
  * has the selection.
  */
-export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? InsertResultTypeTag : O & Selection<DB, TB, S>>;
+export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O & Selection<DB, TB, S>>;
 /**
  * `selectAll` output query builder type.
  */

package/dist/cjs/plugin/immediate-value.ts/immediate-value-plugin.d.ts

@@ -1,6 +1,6 @@
 import { QueryResult } from '../../driver/database-connection.js';
-import { UnknownRow } from '../../index.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import { UnknownRow } from '../../util/type-utils.js';
 import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
 /**
  * Transforms all ValueNodes to immediate.

package/dist/cjs/query-builder/delete-result.d.ts

@@ -0,0 +1,5 @@
+export declare class DeleteResult {
+    #private;
+    constructor(numDeletedRows: bigint);
+    get numDeletedRows(): bigint;
+}

package/dist/cjs/query-builder/delete-result.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteResult = void 0;
+class DeleteResult {
+    #numDeletedRows;
+    constructor(numDeletedRows) {
+        this.#numDeletedRows = numDeletedRows;
+    }
+    get numDeletedRows() {
+        return this.#numDeletedRows;
+    }
+}
+exports.DeleteResult = DeleteResult;

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

@@ -26,7 +26,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -62,7 +62,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * console.log(result[0].owner_name)
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select

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

@@ -34,7 +34,7 @@ class ExpressionBuilder {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"

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

@@ -19,7 +19,7 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
  *   .execute()
  * ```
  *
- * The generated SQL (postgresql):
+ * The generated SQL (PostgreSQL):
  *
  * ```sql
  * select "person"."id", count("pet"."id") as "pet_count"
@@ -66,7 +66,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -83,12 +83,12 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    sum<O extends number | string | BigInt, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
     /**
      * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string |bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -105,7 +105,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    count<O extends number | string | BigInt, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    count<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
 }
 export interface FunctionBuilderProps {
     readonly executor: QueryExecutor;

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

@@ -22,7 +22,7 @@ const query_id_js_1 = require("../util/query-id.js");
  *   .execute()
  * ```
  *
- * The generated SQL (postgresql):
+ * The generated SQL (PostgreSQL):
  *
  * ```sql
  * select "person"."id", count("pet"."id") as "pet_count"
@@ -82,7 +82,7 @@ class FunctionBuilder {
      * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -106,7 +106,7 @@ class FunctionBuilder {
      * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string |bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't

package/dist/cjs/query-builder/insert-result.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The result of an insert query.
+ *
+ * If the table has an auto incrementing primary key {@link insertId} will hold
+ * the generated id on dialects that support it. For example PostgreSQL doesn't
+ * return the id by default and {@link insertId} is undefined. On PostgreSQL you
+ * need to use {@link QueryBuilder.returning} or {@link QueryBuilder.returningAll}
+ * to get out the inserted id.
+ *
+ * @example
+ * ```ts
+ * const result = await db
+ *   .insertInto('person')
+ *   .values(person)
+ *   .executeTakeFirst()
+ *
+ * console.log(result.insertId)
+ * ```
+ */
+export declare class InsertResult {
+    #private;
+    constructor(insertId: bigint | undefined);
+    /**
+     * The auto incrementing primary key
+     */
+    get insertId(): bigint | undefined;
+}

package/dist/cjs/query-builder/insert-result.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertResult = void 0;
+/**
+ * The result of an insert query.
+ *
+ * If the table has an auto incrementing primary key {@link insertId} will hold
+ * the generated id on dialects that support it. For example PostgreSQL doesn't
+ * return the id by default and {@link insertId} is undefined. On PostgreSQL you
+ * need to use {@link QueryBuilder.returning} or {@link QueryBuilder.returningAll}
+ * to get out the inserted id.
+ *
+ * @example
+ * ```ts
+ * const result = await db
+ *   .insertInto('person')
+ *   .values(person)
+ *   .executeTakeFirst()
+ *
+ * console.log(result.insertId)
+ * ```
+ */
+class InsertResult {
+    #insertId;
+    constructor(insertId) {
+        this.#insertId = insertId;
+    }
+    /**
+     * The auto incrementing primary key
+     */
+    get insertId() {
+        return this.#insertId;
+    }
+}
+exports.InsertResult = InsertResult;

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

@@ -4,6 +4,7 @@ import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: JoinBuilderProps);
@@ -15,6 +16,7 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      */
     on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     on(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
+    on(raw: AnyRawBuilder): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.orWhere} but adds an item to the join's
      * `on` clause instead.
@@ -23,6 +25,7 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      */
     orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     orOn(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
+    orOn(raw: AnyRawBuilder): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.whereRef} but adds an item to the join's
      * `on` clause instead.