kysely 0.27.3 → 0.27.4

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

@@ -91,6 +91,7 @@ import { AddIndexNode } from './add-index-node.js';
 import { CastNode } from './cast-node.js';
 import { FetchNode } from './fetch-node.js';
 import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -211,6 +212,7 @@ export declare class OperationNodeTransformer {
     protected transformCast(node: CastNode): CastNode;
     protected transformFetch(node: FetchNode): FetchNode;
     protected transformTop(node: TopNode): TopNode;
+    protected transformOutput(node: OutputNode): OutputNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -127,6 +127,7 @@ class OperationNodeTransformer {
         CastNode: this.transformCast.bind(this),
         FetchNode: this.transformFetch.bind(this),
         TopNode: this.transformTop.bind(this),
+        OutputNode: this.transformOutput.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -268,6 +269,7 @@ class OperationNodeTransformer {
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformValues(node) {
@@ -289,6 +291,7 @@ class OperationNodeTransformer {
             limit: this.transformNode(node.limit),
             explain: this.transformNode(node.explain),
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformReturning(node) {
@@ -329,6 +332,7 @@ class OperationNodeTransformer {
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
             identity: node.identity,
+            ifNotExists: node.ifNotExists,
         });
     }
     transformAddColumn(node) {
@@ -383,6 +387,7 @@ class OperationNodeTransformer {
             explain: this.transformNode(node.explain),
             limit: this.transformNode(node.limit),
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformColumnUpdate(node) {
@@ -794,6 +799,7 @@ class OperationNodeTransformer {
             whens: this.transformNodeList(node.whens),
             with: this.transformNode(node.with),
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformMatched(node) {
@@ -834,6 +840,12 @@ class OperationNodeTransformer {
             modifiers: node.modifiers,
         });
     }
+    transformOutput(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'OutputNode',
+            selections: this.transformNodeList(node.selections),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJSONOperator = exports.isArithmeticOperator = exports.isComparisonOperator = exports.isBinaryOperator = exports.isOperator = exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.JSON_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.JSON_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+exports.isOperator = isOperator;
+exports.isBinaryOperator = isBinaryOperator;
+exports.isComparisonOperator = isComparisonOperator;
+exports.isArithmeticOperator = isArithmeticOperator;
+exports.isJSONOperator = isJSONOperator;
 const object_utils_js_1 = require("../util/object-utils.js");
 exports.COMPARISON_OPERATORS = [
     '=',
@@ -22,9 +27,11 @@ exports.COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '^@',
     '&&',
     '?',
     '?&',
+    '?|',
     '!<',
     '!>',
     '<=>',
@@ -86,20 +93,15 @@ exports.OperatorNode = (0, object_utils_js_1.freeze)({
 function isOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.OPERATORS.includes(op);
 }
-exports.isOperator = isOperator;
 function isBinaryOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.BINARY_OPERATORS.includes(op);
 }
-exports.isBinaryOperator = isBinaryOperator;
 function isComparisonOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.COMPARISON_OPERATORS.includes(op);
 }
-exports.isComparisonOperator = isComparisonOperator;
 function isArithmeticOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.ARITHMETIC_OPERATORS.includes(op);
 }
-exports.isArithmeticOperator = isArithmeticOperator;
 function isJSONOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.JSON_OPERATORS.includes(op);
 }
-exports.isJSONOperator = isJSONOperator;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.OutputNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'OutputNode';
+    },
+    create(selections) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'OutputNode',
+            selections: (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+    cloneWithSelections(output, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...output,
+            selections: output.selections
+                ? (0, object_utils_js_1.freeze)([...output.selections, ...selections])
+                : (0, object_utils_js_1.freeze)(selections),
+        });
+    },
+});

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

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

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

@@ -10,6 +10,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const returning_node_js_1 = require("./returning-node.js");
 const explain_node_js_1 = require("./explain-node.js");
 const merge_query_node_js_1 = require("./merge-query-node.js");
+const output_node_js_1 = require("./output-node.js");
 /**
  * @internal
  */
@@ -67,4 +68,12 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             top,
         });
     },
+    cloneWithOutput(node, selections) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            output: node.output
+                ? output_node_js_1.OutputNode.cloneWithSelections(node.output, selections)
+                : output_node_js_1.OutputNode.create(selections),
+        });
+    },
 });

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

@@ -58,4 +58,5 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
 }>;

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

@@ -132,4 +132,10 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             orderBy: undefined,
         });
     },
+    cloneWithoutGroupBy(select) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            groupBy: undefined,
+        });
+    },
 });

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

@@ -10,6 +10,7 @@ import { FromNode } from './from-node.js';
 import { ExplainNode } from './explain-node.js';
 import { LimitNode } from './limit-node.js';
 import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
@@ -23,6 +24,7 @@ export interface UpdateQueryNode extends OperationNode {
     readonly explain?: ExplainNode;
     readonly limit?: LimitNode;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal

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

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

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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFilterList = exports.parseFilterObject = exports.parseReferentialBinaryOperation = exports.parseValueBinaryOperation = exports.parseValueBinaryOperationOrExpression = void 0;
+exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
+exports.parseValueBinaryOperation = parseValueBinaryOperation;
+exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
+exports.parseFilterObject = parseFilterObject;
+exports.parseFilterList = parseFilterList;
 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");
@@ -20,24 +24,20 @@ function parseValueBinaryOperationOrExpression(args) {
     }
     throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
 }
-exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
 function parseValueBinaryOperation(left, operator, right) {
     if (isIsOperator(operator) && needsIsOperator(right)) {
         return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), value_node_js_1.ValueNode.createImmediate(right));
     }
     return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(right));
 }
-exports.parseValueBinaryOperation = parseValueBinaryOperation;
 function parseReferentialBinaryOperation(left, operator, right) {
     return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(right));
 }
-exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
 function parseFilterObject(obj, combinator) {
     return parseFilterList(Object.entries(obj)
         .filter(([, v]) => !(0, object_utils_js_1.isUndefined)(v))
         .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
-exports.parseFilterObject = parseFilterObject;
 function parseFilterList(list, combinator, withParens = true) {
     const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
     if (list.length === 0) {
@@ -52,7 +52,6 @@ function parseFilterList(list, combinator, withParens = true) {
     }
     return node;
 }
-exports.parseFilterList = parseFilterList;
 function isIsOperator(operator) {
     return operator === 'is' || operator === 'is not';
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDataTypeExpression = void 0;
+exports.parseDataTypeExpression = parseDataTypeExpression;
 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) {
@@ -12,4 +12,3 @@ function parseDataTypeExpression(dataType) {
     }
     throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
 }
-exports.parseDataTypeExpression = parseDataTypeExpression;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDefaultValueExpression = void 0;
+exports.parseDefaultValueExpression = parseDefaultValueExpression;
 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) {
@@ -8,4 +8,3 @@ function parseDefaultValueExpression(value) {
         ? value.toOperationNode()
         : value_node_js_1.ValueNode.createImmediate(value);
 }
-exports.parseDefaultValueExpression = parseDefaultValueExpression;

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExpressionOrFactory = exports.parseAliasedExpression = exports.parseExpression = void 0;
+exports.parseExpression = parseExpression;
+exports.parseAliasedExpression = parseAliasedExpression;
+exports.isExpressionOrFactory = isExpressionOrFactory;
 const expression_js_1 = require("../expression/expression.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const expression_builder_js_1 = require("../expression/expression-builder.js");
@@ -14,7 +16,6 @@ function parseExpression(exp) {
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
-exports.parseExpression = parseExpression;
 function parseAliasedExpression(exp) {
     if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
         return exp.toOperationNode();
@@ -24,8 +25,6 @@ function parseAliasedExpression(exp) {
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
-exports.parseAliasedExpression = parseAliasedExpression;
 function isExpressionOrFactory(obj) {
     return (0, expression_js_1.isExpression)(obj) || (0, expression_js_1.isAliasedExpression)(obj) || (0, object_utils_js_1.isFunction)(obj);
 }
-exports.isExpressionOrFactory = isExpressionOrFactory;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFetch = void 0;
+exports.parseFetch = parseFetch;
 const fetch_node_js_1 = require("../operation-node/fetch-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 function parseFetch(rowCount, modifier) {
@@ -12,7 +12,6 @@ function parseFetch(rowCount, modifier) {
     }
     return fetch_node_js_1.FetchNode.create(rowCount, modifier);
 }
-exports.parseFetch = parseFetch;
 function isFetchModifier(value) {
     return value === 'only' || value === 'with ties';
 }

package/dist/cjs/parser/group-by-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGroupBy = void 0;
+exports.parseGroupBy = parseGroupBy;
 const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
 const expression_builder_js_1 = require("../expression/expression-builder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
@@ -9,4 +9,3 @@ function parseGroupBy(groupBy) {
     groupBy = (0, object_utils_js_1.isFunction)(groupBy) ? groupBy((0, expression_builder_js_1.expressionBuilder)()) : groupBy;
     return (0, reference_parser_js_1.parseReferenceExpressionOrList)(groupBy).map(group_by_item_node_js_1.GroupByItemNode.create);
 }
-exports.parseGroupBy = parseGroupBy;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchemableIdentifier = void 0;
+exports.parseSchemableIdentifier = parseSchemableIdentifier;
 const schemable_identifier_node_js_1 = require("../operation-node/schemable-identifier-node.js");
 function parseSchemableIdentifier(id) {
     const SCHEMA_SEPARATOR = '.';
@@ -17,7 +17,6 @@ function parseSchemableIdentifier(id) {
         return schemable_identifier_node_js_1.SchemableIdentifierNode.create(id);
     }
 }
-exports.parseSchemableIdentifier = parseSchemableIdentifier;
 function trim(str) {
     return str.trim();
 }

package/dist/cjs/parser/insert-values-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInsertExpression = void 0;
+exports.parseInsertExpression = parseInsertExpression;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
@@ -17,7 +17,6 @@ function parseInsertExpression(arg) {
         : (0, object_utils_js_1.freeze)([objectOrList]);
     return parseInsertColumnsAndValues(list);
 }
-exports.parseInsertExpression = parseInsertExpression;
 function parseInsertColumnsAndValues(rows) {
     const columns = parseColumnNamesAndIndexes(rows);
     return [

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJoin = void 0;
+exports.parseJoin = parseJoin;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const table_parser_js_1 = require("./table-parser.js");
 const binary_operation_parser_js_1 = require("./binary-operation-parser.js");
@@ -16,7 +16,6 @@ function parseJoin(joinType, args) {
         throw new Error('not implemented');
     }
 }
-exports.parseJoin = parseJoin;
 function parseCallbackJoin(joinType, from, callback) {
     return callback((0, parse_utils_js_1.createJoinBuilder)(joinType, from)).toOperationNode();
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMergeThen = exports.parseMergeWhen = void 0;
+exports.parseMergeWhen = parseMergeWhen;
+exports.parseMergeThen = parseMergeThen;
 const matched_node_js_1 = require("../operation-node/matched-node.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");
@@ -19,7 +20,6 @@ function parseMergeWhen(type, args, refRight) {
             : []),
     ], 'and', false));
 }
-exports.parseMergeWhen = parseMergeWhen;
 function parseMergeThen(result) {
     if ((0, object_utils_js_1.isString)(result)) {
         return raw_node_js_1.RawNode.create([result], []);
@@ -29,4 +29,3 @@ function parseMergeThen(result) {
     }
     return result;
 }
-exports.parseMergeThen = parseMergeThen;

package/dist/cjs/parser/on-commit-action-parse.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOnCommitAction = void 0;
+exports.parseOnCommitAction = parseOnCommitAction;
 const create_table_node_js_1 = require("../operation-node/create-table-node.js");
 function parseOnCommitAction(action) {
     if (create_table_node_js_1.ON_COMMIT_ACTIONS.includes(action)) {
@@ -8,4 +8,3 @@ function parseOnCommitAction(action) {
     }
     throw new Error(`invalid OnCommitAction ${action}`);
 }
-exports.parseOnCommitAction = parseOnCommitAction;

package/dist/cjs/parser/on-modify-action-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOnModifyForeignAction = void 0;
+exports.parseOnModifyForeignAction = parseOnModifyForeignAction;
 const references_node_js_1 = require("../operation-node/references-node.js");
 function parseOnModifyForeignAction(action) {
     if (references_node_js_1.ON_MODIFY_FOREIGN_ACTIONS.includes(action)) {
@@ -8,4 +8,3 @@ function parseOnModifyForeignAction(action) {
     }
     throw new Error(`invalid OnModifyForeignAction ${action}`);
 }
-exports.parseOnModifyForeignAction = parseOnModifyForeignAction;

package/dist/cjs/parser/order-by-parser.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOrderByItem = exports.parseOrderBy = exports.isOrderByDirection = void 0;
+exports.isOrderByDirection = isOrderByDirection;
+exports.parseOrderBy = parseOrderBy;
+exports.parseOrderByItem = parseOrderByItem;
 const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
 const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
@@ -9,7 +11,6 @@ const reference_parser_js_1 = require("./reference-parser.js");
 function isOrderByDirection(thing) {
     return thing === 'asc' || thing === 'desc';
 }
-exports.isOrderByDirection = isOrderByDirection;
 function parseOrderBy(args) {
     if (args.length === 2) {
         return [parseOrderByItem(args[0], args[1])];
@@ -23,7 +24,6 @@ function parseOrderBy(args) {
     }
     throw new Error(`Invalid number of arguments at order by! expected 1-2, received ${args.length}`);
 }
-exports.parseOrderBy = parseOrderBy;
 function parseOrderByItem(ref, direction) {
     const parsedRef = parseOrderByExpression(ref);
     if (order_by_item_node_js_1.OrderByItemNode.is(parsedRef)) {
@@ -34,7 +34,6 @@ function parseOrderByItem(ref, direction) {
     }
     return order_by_item_node_js_1.OrderByItemNode.create(parsedRef, parseOrderByDirectionExpression(direction));
 }
-exports.parseOrderByItem = parseOrderByItem;
 function parseOrderByExpression(expr) {
     if ((0, expression_parser_js_1.isExpressionOrFactory)(expr)) {
         return (0, expression_parser_js_1.parseExpression)(expr);

package/dist/cjs/parser/parse-utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOverBuilder = exports.createJoinBuilder = exports.createQueryCreator = exports.createSelectQueryBuilder = void 0;
+exports.createSelectQueryBuilder = createSelectQueryBuilder;
+exports.createQueryCreator = createQueryCreator;
+exports.createJoinBuilder = createJoinBuilder;
+exports.createOverBuilder = createOverBuilder;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const over_node_js_1 = require("../operation-node/over-node.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
@@ -18,22 +21,18 @@ function createSelectQueryBuilder() {
         queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)([])),
     });
 }
-exports.createSelectQueryBuilder = createSelectQueryBuilder;
 function createQueryCreator() {
     return new query_creator_js_1.QueryCreator({
         executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
     });
 }
-exports.createQueryCreator = createQueryCreator;
 function createJoinBuilder(joinType, table) {
     return new join_builder_js_1.JoinBuilder({
         joinNode: join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(table)),
     });
 }
-exports.createJoinBuilder = createJoinBuilder;
 function createOverBuilder() {
     return new over_builder_js_1.OverBuilder({
         overNode: over_node_js_1.OverNode.create(),
     });
 }
-exports.createOverBuilder = createOverBuilder;