kysely 0.7.1 → 0.7.5

package/dist/cjs/operation-node/drop-index-node.js

@@ -17,10 +17,10 @@ exports.DropIndexNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWith(dropIndex, params) {
+    cloneWith(dropIndex, props) {
         return (0, object_utils_js_1.freeze)({
             ...dropIndex,
-            ...params,
+            ...props,
         });
     },
 });

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -1,12 +1,15 @@
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-import { ReferencesNode } from './references-node.js';
+import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
 import { TableNode } from './table-node.js';
+export declare type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly references: ReferencesNode;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
     readonly name?: IdentifierNode;
 }
 /**
@@ -15,4 +18,12 @@ export interface ForeignKeyConstraintNode extends OperationNode {
 export declare const ForeignKeyConstraintNode: Readonly<{
     is(node: OperationNode): node is ForeignKeyConstraintNode;
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string | undefined): ForeignKeyConstraintNode;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
+        name?: IdentifierNode | undefined;
+        onDelete?: OnModifyForeignAction | undefined;
+        onUpdate?: OnModifyForeignAction | undefined;
+        kind: 'ForeignKeyConstraintNode';
+        columns: ReadonlyArray<ColumnNode>;
+        references: ReferencesNode;
+    }>;
 }>;

package/dist/cjs/operation-node/foreign-key-constraint-node.js

@@ -19,4 +19,10 @@ exports.ForeignKeyConstraintNode = (0, object_utils_js_1.freeze)({
             name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
         });
     },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
 });

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

@@ -1,5 +1,6 @@
 import { ColumnNode } from './column-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
 import { PrimitiveValueListNode } from './primitive-value-list-node.js';
 import { ReturningNode } from './returning-node.js';
@@ -7,6 +8,7 @@ import { TableNode } from './table-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { WithNode } from './with-node.js';
 export declare type InsertValuesNode = ValueListNode | PrimitiveValueListNode;
+export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
@@ -14,7 +16,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly values?: ReadonlyArray<InsertValuesNode>;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
+    readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
+    readonly ignore?: boolean;
 }
 /**
  * @internal
@@ -22,6 +26,5 @@ export interface InsertQueryNode extends OperationNode {
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
     create(into: TableNode, withNode?: WithNode | undefined): InsertQueryNode;
-    cloneWithColumnsAndValues(insertQuery: InsertQueryNode, columns: ReadonlyArray<ColumnNode>, values: ReadonlyArray<InsertValuesNode>): InsertQueryNode;
-    cloneWithOnConflict(insertQuery: InsertQueryNode, onConflict: OnConflictNode): InsertQueryNode;
+    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/cjs/operation-node/insert-query-node.js

@@ -16,17 +16,10 @@ exports.InsertQueryNode = (0, object_utils_js_1.freeze)({
             ...(withNode && { with: withNode }),
         });
     },
-    cloneWithColumnsAndValues(insertQuery, columns, values) {
+    cloneWith(insertQuery, props) {
         return (0, object_utils_js_1.freeze)({
             ...insertQuery,
-            columns,
-            values,
-        });
-    },
-    cloneWithOnConflict(insertQuery, onConflict) {
-        return (0, object_utils_js_1.freeze)({
-            ...insertQuery,
-            onConflict,
+            ...props,
         });
     },
 });

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

@@ -20,5 +20,6 @@ export interface JoinNode extends OperationNode {
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
+    createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
     cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
 }>;

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

@@ -19,6 +19,14 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
             on: undefined,
         });
     },
+    createWithOn(joinType, table, on) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on,
+        });
+    },
     cloneWithOn(joinNode, op, on) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,

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

@@ -2,7 +2,7 @@ import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type OnConflictNodeParams = Omit<OnConflictNode, 'kind'>;
+export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
@@ -15,5 +15,5 @@ export interface OnConflictNode extends OperationNode {
  */
 export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
-    create(params: OnConflictNodeParams): OnConflictNode;
+    create(props: OnConflictNodeProps): OnConflictNode;
 }>;

package/dist/cjs/operation-node/on-conflict-node.js

@@ -9,10 +9,10 @@ exports.OnConflictNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'OnConflictNode';
     },
-    create(params) {
+    create(props) {
         return (0, object_utils_js_1.freeze)({
             kind: 'OnConflictNode',
-            ...params,
+            ...props,
         });
     },
 });

package/dist/cjs/operation-node/on-duplicate-key-node.d.ts

@@ -0,0 +1,14 @@
+import { ColumnUpdateNode } from './column-update-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>;
+export interface OnDuplicateKeyNode extends OperationNode {
+    readonly kind: 'OnDuplicateKeyNode';
+    readonly updates: ReadonlyArray<ColumnUpdateNode>;
+}
+/**
+ * @internal
+ */
+export declare const OnDuplicateKeyNode: Readonly<{
+    is(node: OperationNode): node is OnDuplicateKeyNode;
+    create(updates: ReadonlyArray<ColumnUpdateNode>): OnDuplicateKeyNode;
+}>;

package/dist/cjs/operation-node/on-duplicate-key-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnDuplicateKeyNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.OnDuplicateKeyNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OnDuplicateKeyNode';
+    },
+    create(updates) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OnDuplicateKeyNode',
+            updates,
+        });
+    },
+});

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

@@ -56,6 +56,7 @@ import { DropConstraintNode } from './drop-constraint-node.js';
 import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -121,6 +122,7 @@ export declare class OperationNodeTransformer {
     protected transformLimit(node: LimitNode): LimitNode;
     protected transformOffset(node: OffsetNode): OffsetNode;
     protected transformOnConflict(node: OnConflictNode): OnConflictNode;
+    protected transformOnDuplicateKey(node: OnDuplicateKeyNode): OnDuplicateKeyNode;
     protected transformCreateIndex(node: CreateIndexNode): CreateIndexNode;
     protected transformList(node: ListNode): ListNode;
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;

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

@@ -71,6 +71,7 @@ class OperationNodeTransformer {
         LimitNode: this.transformLimit.bind(this),
         OffsetNode: this.transformOffset.bind(this),
         OnConflictNode: this.transformOnConflict.bind(this),
+        OnDuplicateKeyNode: this.transformOnDuplicateKey.bind(this),
         CreateIndexNode: this.transformCreateIndex.bind(this),
         DropIndexNode: this.transformDropIndex.bind(this),
         ListNode: this.transformList.bind(this),
@@ -227,7 +228,9 @@ class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
+            onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
+            ignore: node.ignore,
         };
     }
     transformDeleteQuery(node) {
@@ -346,6 +349,12 @@ class OperationNodeTransformer {
             doNothing: node.doNothing,
         };
     }
+    transformOnDuplicateKey(node) {
+        return {
+            kind: 'OnDuplicateKeyNode',
+            updates: this.transformNodeList(node.updates),
+        };
+    }
     transformCreateIndex(node) {
         return {
             kind: 'CreateIndexNode',
@@ -390,6 +399,8 @@ class OperationNodeTransformer {
             columns: this.transformNodeList(node.columns),
             references: this.transformNode(node.references),
             name: this.transformNode(node.name),
+            onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformReferences(node) {
@@ -398,6 +409,7 @@ class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformCheckConstraint(node) {

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

@@ -56,6 +56,7 @@ import { DropConstraintNode } from './drop-constraint-node.js';
 import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 export declare class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -91,6 +92,7 @@ export declare class OperationNodeVisitor {
     protected visitLimit(node: LimitNode): void;
     protected visitOffset(node: OffsetNode): void;
     protected visitOnConflict(node: OnConflictNode): void;
+    protected visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
     protected visitCreateIndex(node: CreateIndexNode): void;
     protected visitList(node: ListNode): void;
     protected visitDropIndex(node: DropIndexNode): void;

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

@@ -41,6 +41,7 @@ class OperationNodeVisitor {
         LimitNode: this.visitLimit.bind(this),
         OffsetNode: this.visitOffset.bind(this),
         OnConflictNode: this.visitOnConflict.bind(this),
+        OnDuplicateKeyNode: this.visitOnDuplicateKey.bind(this),
         CreateIndexNode: this.visitCreateIndex.bind(this),
         DropIndexNode: this.visitDropIndex.bind(this),
         ListNode: this.visitList.bind(this),
@@ -265,6 +266,9 @@ class OperationNodeVisitor {
             node.updates.forEach(this.visitNode);
         }
     }
+    visitOnDuplicateKey(node) {
+        node.updates.forEach(this.visitNode);
+    }
     visitCreateIndex(node) {
         this.visitNode(node.name);
         if (node.table) {

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' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode';
+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';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,12 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
-export declare type OnDelete = 'cascade' | 'set null';
+export declare type OnModifyForeignAction = 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default';
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnNode>;
-    readonly onDelete?: OnDelete;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
 }
 /**
  * @internal
@@ -14,5 +15,6 @@ export interface ReferencesNode extends OperationNode {
 export declare const ReferencesNode: Readonly<{
     is(node: OperationNode): node is ReferencesNode;
     create(table: TableNode, columns: ReadonlyArray<ColumnNode>): ReferencesNode;
-    cloneWithOnDelete(references: ReferencesNode, onDelete: OnDelete): ReferencesNode;
+    cloneWithOnDelete(references: ReferencesNode, onDelete: OnModifyForeignAction): ReferencesNode;
+    cloneWithOnUpdate(references: ReferencesNode, onUpdate: OnModifyForeignAction): ReferencesNode;
 }>;

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

@@ -22,4 +22,10 @@ exports.ReferencesNode = (0, object_utils_js_1.freeze)({
             onDelete,
         });
     },
+    cloneWithOnUpdate(references, onUpdate) {
+        return (0, object_utils_js_1.freeze)({
+            ...references,
+            onUpdate,
+        });
+    },
 });

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

@@ -11,10 +11,10 @@ exports.TableNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'TableNode';
     },
     create(table) {
-        return {
+        return (0, object_utils_js_1.freeze)({
             kind: 'TableNode',
             table: identifier_node_js_1.IdentifierNode.create(table),
-        };
+        });
     },
     createWithSchema(schema, table) {
         return (0, object_utils_js_1.freeze)({

package/dist/cjs/parser/data-type-parser.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDataType, DataTypeNode } from '../operation-node/data-type-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+export declare type DataTypeExpression = ColumnDataType | AnyRawBuilder;
+export declare function parseDataTypeExpression(dataType: DataTypeExpression): DataTypeNode | RawNode;

package/dist/cjs/parser/data-type-parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDataTypeExpression = void 0;
+const data_type_node_js_1 = require("../operation-node/data-type-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+function parseDataTypeExpression(dataType) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(dataType)
+        ? dataType.toOperationNode()
+        : data_type_node_js_1.DataTypeNode.create(dataType);
+}
+exports.parseDataTypeExpression = parseDataTypeExpression;

package/dist/cjs/parser/default-value-parser.d.ts

@@ -0,0 +1,6 @@
+import { RawNode } from '../operation-node/raw-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+export declare type DefaultValueExpression = PrimitiveValue | AnyRawBuilder;
+export declare function parseDefaultValueExpression(value: DefaultValueExpression): ValueNode | RawNode;

package/dist/cjs/parser/default-value-parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefaultValueExpression = void 0;
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function parseDefaultValueExpression(value) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(value)
+        ? value.toOperationNode()
+        : value_node_js_1.ValueNode.createImmediate(value);
+}
+exports.parseDefaultValueExpression = parseDefaultValueExpression;

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

@@ -10,5 +10,5 @@ export declare function parseWhereFilter(ctx: ParseContext, args: any[]): Filter
 export declare function parseHavingFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
-export declare function parseExistExpression(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseNotExistExpression(ctx: ParseContext, arg: ExistsExpression<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;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNotExistExpression = exports.parseExistExpression = exports.parseReferenceFilter = exports.parseOnFilter = exports.parseHavingFilter = exports.parseWhereFilter = void 0;
+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");
@@ -11,13 +11,12 @@ const reference_parser_js_1 = require("./reference-parser.js");
 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");
-const table_parser_js_1 = require("./table-parser.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 parseWhereGrouper(ctx, args[0]);
+        return parseWhereGroup(ctx, args[0]);
     }
     else {
         throw new Error(`invalid arguments passed to a where method ${JSON.stringify(args)}`);
@@ -29,7 +28,7 @@ function parseHavingFilter(ctx, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && (0, object_utils_js_1.isFunction)(args[0])) {
-        return parseHavingGrouper(ctx, args[0]);
+        return parseHavingGroup(ctx, args[0]);
     }
     else {
         throw new Error(`invalid arguments passed to a having method ${JSON.stringify(args)}`);
@@ -41,7 +40,7 @@ function parseOnFilter(ctx, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && (0, object_utils_js_1.isFunction)(args[0])) {
-        return parseOnGrouper(ctx, args[0]);
+        return parseOnGroup(ctx, args[0]);
     }
     else {
         throw new Error(`invalid arguments passed to an on method ${JSON.stringify(args)}`);
@@ -52,23 +51,14 @@ function parseReferenceFilter(ctx, lhs, op, rhs) {
     return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, lhs), parseFilterOperator(op), (0, reference_parser_js_1.parseReferenceExpression)(ctx, rhs));
 }
 exports.parseReferenceFilter = parseReferenceFilter;
-function parseExistExpression(ctx, arg) {
-    return doParseExistExpression(ctx, 'exists', arg);
+function parseExistFilter(ctx, arg) {
+    return parseExistExpression(ctx, 'exists', arg);
 }
-exports.parseExistExpression = parseExistExpression;
-function parseNotExistExpression(ctx, arg) {
-    return doParseExistExpression(ctx, 'not exists', arg);
-}
-exports.parseNotExistExpression = parseNotExistExpression;
-function doParseExistExpression(ctx, type, arg) {
-    const node = (0, object_utils_js_1.isFunction)(arg)
-        ? arg(ctx.createSubQueryBuilder()).toOperationNode()
-        : arg.toOperationNode();
-    if (!select_query_node_js_1.SelectQueryNode.is(node) && !raw_node_js_1.RawNode.is(node)) {
-        throw new Error('invalid where exists arg');
-    }
-    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), node);
+exports.parseExistFilter = parseExistFilter;
+function parseNotExistFilter(ctx, arg) {
+    return parseExistExpression(ctx, 'not exists', arg);
 }
+exports.parseNotExistFilter = parseNotExistFilter;
 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,38 +69,46 @@ function parseIsFilter(ctx, left, op, right) {
     return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, left), parseFilterOperator(op), value_node_js_1.ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
-    if ((0, operation_node_source_js_1.isOperationNodeSource)(op)) {
-        return op.toOperationNode();
-    }
-    else if ((0, object_utils_js_1.isString)(op)) {
-        const opString = op.trim().toLowerCase();
-        if (operator_node_js_1.OPERATORS.some((it) => it === opString)) {
-            return operator_node_js_1.OperatorNode.create(opString);
+    if ((0, object_utils_js_1.isString)(op)) {
+        if (operator_node_js_1.OPERATORS.includes(op)) {
+            return operator_node_js_1.OperatorNode.create(op);
         }
     }
+    else if ((0, operation_node_source_js_1.isOperationNodeSource)(op)) {
+        return op.toOperationNode();
+    }
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
-function parseWhereGrouper(ctx, grouper) {
-    const query = grouper(ctx.createEmptySelectQuery());
+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 grouper');
+        throw new Error('no `where*` methods called insided a group callback');
     }
     return parens_node_js_1.ParensNode.create(queryNode.where.where);
 }
-function parseHavingGrouper(ctx, grouper) {
-    const query = grouper(ctx.createEmptySelectQuery());
+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 grouper');
+        throw new Error('no `having*` methods called insided a group callback');
     }
     return parens_node_js_1.ParensNode.create(queryNode.having.having);
 }
-function parseOnGrouper(ctx, grouper) {
-    const joinBuilder = grouper(ctx.createJoinBuilder('InnerJoin', (0, table_parser_js_1.parseTableExpression)(ctx, 'table')));
+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 grouper where');
+        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()
+        : arg.toOperationNode();
+    if (!select_query_node_js_1.SelectQueryNode.is(node) && !raw_node_js_1.RawNode.is(node)) {
+        throw new Error('invalid where exists arg');
+    }
+    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), node);
+}

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

@@ -5,4 +5,4 @@ import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';
 export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
 export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
-export declare function parseJoinArgs(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
+export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;

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

@@ -1,27 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJoinArgs = void 0;
+exports.parseJoin = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const table_parser_js_1 = require("./table-parser.js");
 const filter_parser_js_1 = require("./filter-parser.js");
-function parseJoinArgs(ctx, joinType, args) {
-    if (args.length === 2) {
-        return parseCallbackJoin(ctx, joinType, args[0], args[1]);
-    }
-    else if (args.length === 3) {
+function parseJoin(ctx, joinType, args) {
+    if (args.length === 3) {
         return parseSingleOnJoin(ctx, joinType, args[0], args[1], args[2]);
     }
+    else if (args.length === 2) {
+        return parseCallbackJoin(ctx, joinType, args[0], args[1]);
+    }
     else {
         throw new Error('not implemented');
     }
 }
-exports.parseJoinArgs = parseJoinArgs;
+exports.parseJoin = parseJoin;
 function parseCallbackJoin(ctx, joinType, from, callback) {
-    const tableNode = (0, table_parser_js_1.parseTableExpression)(ctx, from);
-    const joinBuilder = callback(ctx.createJoinBuilder(joinType, tableNode));
+    const joinBuilder = callback(ctx.createJoinBuilder(joinType, from));
     return joinBuilder.toOperationNode();
 }
 function parseSingleOnJoin(ctx, joinType, from, lhsColumn, rhsColumn) {
-    const tableNode = (0, table_parser_js_1.parseTableExpression)(ctx, from);
-    return join_node_js_1.JoinNode.cloneWithOn(join_node_js_1.JoinNode.create(joinType, tableNode), 'And', (0, filter_parser_js_1.parseReferenceFilter)(ctx, lhsColumn, '=', rhsColumn));
+    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(ctx, from), (0, filter_parser_js_1.parseReferenceFilter)(ctx, lhsColumn, '=', rhsColumn));
 }

package/dist/cjs/parser/parse-context.d.ts

@@ -1,14 +1,41 @@
-import { DialectAdapter } from '../index.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
 import { JoinType } from '../operation-node/join-node.js';
-import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
-import { SubQueryBuilder } from '../query-builder/sub-query-builder.js';
+import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { QueryCreator } from '../query-creator.js';
+import { TableExpression } from './table-parser.js';
+/**
+ * This interface exposes everything the parsers need to be able to parse
+ * method calls into {@link OperationNode} trees.
+ */
 export interface ParseContext {
-    createEmptySelectQuery(): QueryBuilder<any, any>;
-    createSubQueryBuilder(): SubQueryBuilder<any, any>;
+    readonly adapter: DialectAdapter;
+    /**
+     * Creates a select query builder with a {@link NoopQueryExecutor}.
+     */
+    createSelectQueryBuilder(tables: ReadonlyArray<TableExpression<any, any>>): QueryBuilder<any, any>;
+    /**
+     * Creates an instance of a join builder.
+     */
+    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+    /**
+     * Creates an expression builder for building stuff like subqueries.
+     * {@link NoopQueryExecutor} is used as the executor and the queries
+     * built using the returned builder can never be executed.
+     */
+    createExpressionBuilder(): ExpressionBuilder<any, any>;
+    /**
+     * Creates a query creator with a {@link NoopQueryExecutor}.
+     */
+    createQueryCreator(): QueryCreator<any>;
+}
+export declare class DefaultParseContext implements ParseContext {
+    #private;
+    constructor(adapter: DialectAdapter);
+    get adapter(): DialectAdapter;
+    createSelectQueryBuilder(tables: ReadonlyArray<TableExpression<any, any>>): QueryBuilder<any, any>;
+    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+    createExpressionBuilder(): ExpressionBuilder<any, any>;
     createQueryCreator(): QueryCreator<any>;
-    createJoinBuilder(joinType: JoinType, tableNode: TableExpressionNode): JoinBuilder<any, any>;
 }
-export declare function createParseContext(adapter: DialectAdapter): ParseContext;