kysely 0.21.6 → 0.23.0

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const order_by_node_js_1 = require("./order-by-node.js");
+const partition_by_node_js_1 = require("./partition-by-node.js");
+/**
+ * @internal
+ */
+exports.OverNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OverNode';
+    },
+    create() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OverNode',
+        });
+    },
+    cloneWithOrderByItem(overNode, item) {
+        return (0, object_utils_js_1.freeze)({
+            ...overNode,
+            orderBy: overNode.orderBy
+                ? order_by_node_js_1.OrderByNode.cloneWithItem(overNode.orderBy, item)
+                : order_by_node_js_1.OrderByNode.create(item),
+        });
+    },
+    cloneWithPartitionByItems(overNode, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...overNode,
+            partitionBy: overNode.partitionBy
+                ? partition_by_node_js_1.PartitionByNode.cloneWithItems(overNode.partitionBy, items)
+                : partition_by_node_js_1.PartitionByNode.create(items),
+        });
+    },
+});

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

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 export interface ParensNode extends OperationNode {
     readonly kind: 'ParensNode';
-    readonly node: FilterExpressionNode;
+    readonly node: OperationNode;
 }
 /**
  * @internal
  */
 export declare const ParensNode: Readonly<{
     is(node: OperationNode): node is ParensNode;
-    create(node: FilterExpressionNode): ParensNode;
+    create(node: OperationNode): ParensNode;
 }>;

package/dist/cjs/operation-node/partition-by-item-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+export interface PartitionByItemNode extends OperationNode {
+    readonly kind: 'PartitionByItemNode';
+    readonly partitionBy: SimpleReferenceExpressionNode;
+}
+/**
+ * @internal
+ */
+export declare const PartitionByItemNode: Readonly<{
+    is(node: OperationNode): node is PartitionByItemNode;
+    create(partitionBy: SimpleReferenceExpressionNode): PartitionByItemNode;
+}>;

package/dist/cjs/operation-node/{filter-node.js → partition-by-item-node.js}

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

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

@@ -0,0 +1,14 @@
+import { PartitionByItemNode } from './partition-by-item-node.js';
+import { OperationNode } from './operation-node.js';
+export interface PartitionByNode extends OperationNode {
+    readonly kind: 'PartitionByNode';
+    readonly items: ReadonlyArray<PartitionByItemNode>;
+}
+/**
+ * @internal
+ */
+export declare const PartitionByNode: Readonly<{
+    is(node: OperationNode): node is PartitionByNode;
+    create(items: ReadonlyArray<PartitionByItemNode>): PartitionByNode;
+    cloneWithItems(partitionBy: PartitionByNode, items: ReadonlyArray<PartitionByItemNode>): PartitionByNode;
+}>;

package/dist/cjs/operation-node/partition-by-node.js

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

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

@@ -5,7 +5,6 @@ import { DeleteQueryNode } from './delete-query-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;
@@ -14,8 +13,8 @@ export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | Up
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
-    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, operation: OperationNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, operation: OperationNode): 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/query-node.js

@@ -18,20 +18,20 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             update_query_node_js_1.UpdateQueryNode.is(node) ||
             select_query_node_js_1.SelectQueryNode.is(node));
     },
-    cloneWithWhere(node, filter) {
+    cloneWithWhere(node, operation) {
         return (0, object_utils_js_1.freeze)({
             ...node,
             where: node.where
-                ? where_node_js_1.WhereNode.cloneWithFilter(node.where, 'And', filter)
-                : where_node_js_1.WhereNode.create(filter),
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.where, 'And', operation)
+                : where_node_js_1.WhereNode.create(operation),
         });
     },
-    cloneWithOrWhere(node, filter) {
+    cloneWithOrWhere(node, operation) {
         return (0, object_utils_js_1.freeze)({
             ...node,
             where: node.where
-                ? where_node_js_1.WhereNode.cloneWithFilter(node.where, 'Or', filter)
-                : where_node_js_1.WhereNode.create(filter),
+                ? where_node_js_1.WhereNode.cloneWithOperation(node.where, 'Or', operation)
+                : where_node_js_1.WhereNode.create(operation),
         });
     },
     cloneWithJoin(node, join) {

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

@@ -1,10 +1,9 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
 export interface SelectModifierNode extends OperationNode {
     readonly kind: 'SelectModifierNode';
     readonly modifier?: SelectModifier;
-    readonly rawModifier?: RawNode;
+    readonly rawModifier?: OperationNode;
 }
 /**
  * @internal
@@ -12,5 +11,5 @@ export interface SelectModifierNode extends OperationNode {
 export declare const SelectModifierNode: Readonly<{
     is(node: OperationNode): node is SelectModifierNode;
     create(modifier: SelectModifier): SelectModifierNode;
-    createWithRaw(modifier: RawNode): SelectModifierNode;
+    createWithExpression(modifier: OperationNode): SelectModifierNode;
 }>;

package/dist/cjs/operation-node/select-modifier-node.js

@@ -15,7 +15,7 @@ exports.SelectModifierNode = (0, object_utils_js_1.freeze)({
             modifier,
         });
     },
-    createWithRaw(modifier) {
+    createWithExpression(modifier) {
         return (0, object_utils_js_1.freeze)({
             kind: 'SelectModifierNode',
             rawModifier: modifier,

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

@@ -6,20 +6,19 @@ 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 { 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';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
-import { UnionNode } from './union-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { ExplainNode } from './explain-node.js';
+import { SetOperationNode } from './set-operation-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
-    readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
+    readonly distinctOn?: ReadonlyArray<OperationNode>;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
@@ -30,25 +29,25 @@ export interface SelectQueryNode extends OperationNode {
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
     readonly having?: HavingNode;
-    readonly union?: ReadonlyArray<UnionNode>;
     readonly explain?: ExplainNode;
+    readonly setOperations?: ReadonlyArray<SetOperationNode>;
 }
 /**
  * @internal
  */
 export declare const SelectQueryNode: Readonly<{
     is(node: OperationNode): node is SelectQueryNode;
-    create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode): SelectQueryNode;
+    create(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
-    cloneWithDistinctOnSelections(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;
     cloneWithOrderByItem(selectNode: SelectQueryNode, item: OrderByItemNode): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
+    cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
 }>;

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

@@ -28,12 +28,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)(selections),
         });
     },
-    cloneWithDistinctOnSelections(select, selections) {
+    cloneWithDistinctOn(select, expressions) {
         return (0, object_utils_js_1.freeze)({
             ...select,
-            distinctOnSelections: select.distinctOnSelections
-                ? (0, object_utils_js_1.freeze)([...select.distinctOnSelections, ...selections])
-                : (0, object_utils_js_1.freeze)(selections),
+            distinctOn: select.distinctOn
+                ? (0, object_utils_js_1.freeze)([...select.distinctOn, ...expressions])
+                : (0, object_utils_js_1.freeze)(expressions),
         });
     },
     cloneWithFrontModifier(select, modifier) {
@@ -80,28 +80,28 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             offset,
         });
     },
-    cloneWithHaving(selectNode, filter) {
+    cloneWithHaving(selectNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
             having: selectNode.having
-                ? having_node_js_1.HavingNode.cloneWithFilter(selectNode.having, 'And', filter)
-                : having_node_js_1.HavingNode.create(filter),
+                ? having_node_js_1.HavingNode.cloneWithOperation(selectNode.having, 'And', operation)
+                : having_node_js_1.HavingNode.create(operation),
         });
     },
-    cloneWithOrHaving(selectNode, filter) {
+    cloneWithOrHaving(selectNode, operation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
             having: selectNode.having
-                ? having_node_js_1.HavingNode.cloneWithFilter(selectNode.having, 'Or', filter)
-                : having_node_js_1.HavingNode.create(filter),
+                ? having_node_js_1.HavingNode.cloneWithOperation(selectNode.having, 'Or', operation)
+                : having_node_js_1.HavingNode.create(operation),
         });
     },
-    cloneWithUnion(selectNode, union) {
+    cloneWithSetOperation(selectNode, setOperation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
-            union: selectNode.union
-                ? (0, object_utils_js_1.freeze)([...selectNode.union, union])
-                : (0, object_utils_js_1.freeze)([union]),
+            setOperations: selectNode.setOperations
+                ? (0, object_utils_js_1.freeze)([...selectNode.setOperations, setOperation])
+                : (0, object_utils_js_1.freeze)([setOperation]),
         });
     },
     cloneWithExplain(selectNode, explain) {

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

@@ -1,10 +1,9 @@
 import { AliasNode } from './alias-node.js';
-import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
-import { ReferenceNode } from './reference-node.js';
 import { SelectAllNode } from './select-all-node.js';
+import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { TableNode } from './table-node.js';
-declare type SelectionNodeChild = ColumnNode | ReferenceNode | AliasNode | SelectAllNode;
+declare type SelectionNodeChild = SimpleReferenceExpressionNode | AliasNode | SelectAllNode;
 export interface SelectionNode extends OperationNode {
     readonly kind: 'SelectionNode';
     readonly selection: SelectionNodeChild;

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

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+export declare type SetOperator = 'union' | 'intersect' | 'except';
+export interface SetOperationNode extends OperationNode {
+    kind: 'SetOperationNode';
+    operator: SetOperator;
+    expression: OperationNode;
+    all: boolean;
+}
+/**
+ * @internal
+ */
+export declare const SetOperationNode: Readonly<{
+    is(node: OperationNode): node is SetOperationNode;
+    create(operator: SetOperator, expression: OperationNode, all: boolean): SetOperationNode;
+}>;

package/dist/cjs/operation-node/{union-node.js → set-operation-node.js}

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

package/dist/cjs/operation-node/simple-reference-expression-node.d.ts

@@ -0,0 +1,3 @@
+import { ColumnNode } from './column-node.js';
+import { ReferenceNode } from './reference-node.js';
+export declare type SimpleReferenceExpressionNode = ColumnNode | ReferenceNode;

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

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

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

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

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

@@ -1,7 +1,6 @@
 import { ColumnUpdateNode } from './column-update-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 import { PrimitiveValueListNode } from './primitive-value-list-node.js';
 import { ReturningNode } from './returning-node.js';
 import { ValueListNode } from './value-list-node.js';
@@ -12,7 +11,7 @@ import { ExplainNode } from './explain-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
-    readonly table: TableExpressionNode;
+    readonly table: OperationNode;
     readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
@@ -26,8 +25,8 @@ export interface UpdateQueryNode extends OperationNode {
  */
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
-    create(table: TableExpressionNode, withNode?: WithNode): UpdateQueryNode;
-    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
+    create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
     cloneWithExplain(updateQuery: UpdateQueryNode, explain: ExplainNode): UpdateQueryNode;
 }>;

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

@@ -1,18 +1,12 @@
-import { DefaultInsertValueNode } from './default-insert-value-node.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { ReferenceNode } from './reference-node.js';
-import { SelectQueryNode } from './select-query-node.js';
-import { ValueNode } from './value-node.js';
-export declare type ListNodeItem = ValueNode | ReferenceNode | DefaultInsertValueNode | SelectQueryNode | RawNode;
 export interface ValueListNode extends OperationNode {
     readonly kind: 'ValueListNode';
-    readonly values: ReadonlyArray<ListNodeItem>;
+    readonly values: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const ValueListNode: Readonly<{
     is(node: OperationNode): node is ValueListNode;
-    create(values: ReadonlyArray<ListNodeItem>): ValueListNode;
+    create(values: ReadonlyArray<OperationNode>): ValueListNode;
 }>;

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

@@ -1,14 +1,13 @@
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface WhereNode extends OperationNode {
     readonly kind: 'WhereNode';
-    readonly where: FilterExpressionNode;
+    readonly where: OperationNode;
 }
 /**
  * @internal
  */
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
-    create(filter: FilterExpressionNode): WhereNode;
-    cloneWithFilter(whereNode: WhereNode, op: 'And' | 'Or', filter: FilterExpressionNode): WhereNode;
+    create(filter: OperationNode): WhereNode;
+    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): 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, filter) {
+    cloneWithOperation(whereNode, operator, operation) {
         return (0, object_utils_js_1.freeze)({
             ...whereNode,
-            where: op === 'And'
-                ? and_node_js_1.AndNode.create(whereNode.where, filter)
-                : or_node_js_1.OrNode.create(whereNode.where, filter),
+            where: operator === 'And'
+                ? and_node_js_1.AndNode.create(whereNode.where, operation)
+                : or_node_js_1.OrNode.create(whereNode.where, operation),
         });
     },
 });

package/dist/cjs/parser/binary-operation-parser.d.ts

@@ -0,0 +1,20 @@
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { ComparisonOperator } from '../operation-node/operator-node.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
+import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
+import { WhereInterface } from '../query-builder/where-interface.js';
+import { HavingInterface } from '../query-builder/having-interface.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { Expression } from '../expression/expression.js';
+export declare type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
+export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
+export declare type ComparisonOperatorExpression = ComparisonOperator | Expression<any>;
+declare type FilterExpressionType = 'where' | 'having' | 'on';
+export declare function parseWhere(args: any[]): OperationNode;
+export declare function parseHaving(args: any[]): OperationNode;
+export declare function parseOn(args: any[]): OperationNode;
+export declare function parseReferentialFilter(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: ReferenceExpression<any, any>): BinaryOperationNode;
+export declare function parseFilterExpression(type: FilterExpressionType, args: any[]): OperationNode;
+export {};

package/dist/cjs/parser/binary-operation-parser.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFilterExpression = exports.parseReferentialFilter = exports.parseOn = exports.parseHaving = exports.parseWhere = void 0;
+const binary_operation_node_js_1 = require("../operation-node/binary-operation-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");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+const value_parser_js_1 = require("./value-parser.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+const parse_utils_js_1 = require("./parse-utils.js");
+function parseWhere(args) {
+    return parseFilterExpression('where', args);
+}
+exports.parseWhere = parseWhere;
+function parseHaving(args) {
+    return parseFilterExpression('having', args);
+}
+exports.parseHaving = parseHaving;
+function parseOn(args) {
+    return parseFilterExpression('on', args);
+}
+exports.parseOn = parseOn;
+function parseReferentialFilter(leftOperand, operator, rightOperand) {
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseComparisonOperatorExpression(operator), (0, reference_parser_js_1.parseReferenceExpression)(rightOperand));
+}
+exports.parseReferentialFilter = parseReferentialFilter;
+function parseFilterExpression(type, args) {
+    if (args.length === 3) {
+        return parseFilter(args[0], args[1], args[2]);
+    }
+    if (args.length === 1) {
+        return parseOneArgFilterExpression(type, args[0]);
+    }
+    throw createFilterExpressionError(type, args);
+}
+exports.parseFilterExpression = parseFilterExpression;
+function parseFilter(leftOperand, operator, rightOperand) {
+    if ((operator === 'is' || operator === 'is not') &&
+        ((0, object_utils_js_1.isNull)(rightOperand) || (0, object_utils_js_1.isBoolean)(rightOperand))) {
+        return parseIs(leftOperand, operator, rightOperand);
+    }
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseComparisonOperatorExpression(operator), (0, value_parser_js_1.parseValueExpressionOrList)(rightOperand));
+}
+function parseIs(leftOperand, operator, rightOperand) {
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseComparisonOperatorExpression(operator), value_node_js_1.ValueNode.createImmediate(rightOperand));
+}
+function parseComparisonOperatorExpression(operator) {
+    if ((0, object_utils_js_1.isString)(operator) && operator_node_js_1.COMPARISON_OPERATORS.includes(operator)) {
+        return operator_node_js_1.OperatorNode.create(operator);
+    }
+    else if ((0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+        return operator.toOperationNode();
+    }
+    throw new Error(`invalid comparison operator ${JSON.stringify(operator)} passed to a filter method`);
+}
+function parseOneArgFilterExpression(type, arg) {
+    if ((0, object_utils_js_1.isFunction)(arg)) {
+        return GROUP_PARSERS[type](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 createFilterExpressionError(type, arg);
+}
+function createFilterExpressionError(type, args) {
+    return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+}
+const GROUP_PARSERS = (0, object_utils_js_1.freeze)({
+    where(callback) {
+        const query = callback((0, parse_utils_js_1.createSelectQueryBuilder)());
+        const queryNode = query.toOperationNode();
+        if (!queryNode.where) {
+            throw new Error('no `where` methods called inside a group callback');
+        }
+        return parens_node_js_1.ParensNode.create(queryNode.where.where);
+    },
+    having(callback) {
+        const query = callback((0, parse_utils_js_1.createSelectQueryBuilder)());
+        const queryNode = query.toOperationNode();
+        if (!queryNode.having) {
+            throw new Error('no `having` methods called inside a group callback');
+        }
+        return parens_node_js_1.ParensNode.create(queryNode.having.having);
+    },
+    on(callback) {
+        const joinBuilder = callback((0, parse_utils_js_1.createJoinBuilder)('InnerJoin', 'table'));
+        const joinNode = joinBuilder.toOperationNode();
+        if (!joinNode.on) {
+            throw new Error('no `on` methods called inside a group callback');
+        }
+        return parens_node_js_1.ParensNode.create(joinNode.on.on);
+    },
+});

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

@@ -0,0 +1,4 @@
+import { RawNode } from '../operation-node/raw-node.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
+export declare type CoalesceReferenceExpressionList<DB, TB extends keyof DB, RE extends unknown[], O = never> = RE extends [] ? O : RE extends [infer L, ...infer R] ? L extends ReferenceExpression<any, any> ? null extends ExtractTypeFromReferenceExpression<DB, TB, L> ? CoalesceReferenceExpressionList<DB, TB, R extends ReferenceExpression<any, any>[] ? R : never, O | ExtractTypeFromReferenceExpression<DB, TB, L>> : Exclude<O, null> | ExtractTypeFromReferenceExpression<DB, TB, L> : never : never;
+export declare function parseCoalesce(values: ReferenceExpression<any, any>[]): RawNode;