kysely 0.25.0 → 0.26.1

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

@@ -116,6 +116,10 @@ class OperationNodeTransformer {
         FunctionNode: this.transformFunction.bind(this),
         CaseNode: this.transformCase.bind(this),
         WhenNode: this.transformWhen.bind(this),
+        JSONReferenceNode: this.transformJSONReference.bind(this),
+        JSONPathNode: this.transformJSONPath.bind(this),
+        JSONPathLegNode: this.transformJSONPathLeg.bind(this),
+        JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -189,8 +193,8 @@ class OperationNodeTransformer {
     transformReference(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ReferenceNode',
-            table: this.transformNode(node.table),
             column: this.transformNode(node.column),
+            table: this.transformNode(node.table),
         });
     }
     transformAnd(node) {
@@ -725,6 +729,34 @@ class OperationNodeTransformer {
             result: this.transformNode(node.result),
         });
     }
+    transformJSONReference(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONReferenceNode',
+            reference: this.transformNode(node.reference),
+            traversal: this.transformNode(node.traversal),
+        });
+    }
+    transformJSONPath(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONPathNode',
+            inOperator: this.transformNode(node.inOperator),
+            pathLegs: this.transformNodeList(node.pathLegs),
+        });
+    }
+    transformJSONPathLeg(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONPathLegNode',
+            type: node.type,
+            value: node.value,
+        });
+    }
+    transformJSONOperatorChain(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONOperatorChainNode',
+            operator: this.transformNode(node.operator),
+            values: this.transformNodeList(node.values),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -80,6 +80,10 @@ import { UsingNode } from './using-node.js';
 import { FunctionNode } from './function-node.js';
 import { WhenNode } from './when-node.js';
 import { CaseNode } from './case-node.js';
+import { JSONReferenceNode } from './json-reference-node.js';
+import { JSONPathNode } from './json-path-node.js';
+import { JSONPathLegNode } from './json-path-leg-node.js';
+import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -166,4 +170,8 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitFunction(node: FunctionNode): void;
     protected abstract visitCase(node: CaseNode): void;
     protected abstract visitWhen(node: WhenNode): void;
+    protected abstract visitJSONReference(node: JSONReferenceNode): void;
+    protected abstract visitJSONPath(node: JSONPathNode): void;
+    protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
+    protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
 }

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

@@ -89,6 +89,10 @@ class OperationNodeVisitor {
         FunctionNode: this.visitFunction.bind(this),
         CaseNode: this.visitCase.bind(this),
         WhenNode: this.visitWhen.bind(this),
+        JSONReferenceNode: this.visitJSONReference.bind(this),
+        JSONPathNode: this.visitJSONPath.bind(this),
+        JSONPathLegNode: this.visitJSONPathLeg.bind(this),
+        JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export declare 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';
+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';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,16 +1,19 @@
 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", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+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", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 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", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "not", "-", "exists", "not exists"];
-export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
-export declare type ArithmeticOperator = typeof ARITHMETIC_OPERATORS[number];
-export declare type BinaryOperator = typeof BINARY_OPERATORS[number];
-export declare type UnaryOperator = typeof UNARY_OPERATORS[number];
-export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];
-export declare type Operator = typeof OPERATORS[number];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists"];
+export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
+export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
+export type JSONOperator = (typeof JSON_OPERATORS)[number];
+export type JSONOperatorWith$ = JSONOperator | `${JSONOperator}$`;
+export type BinaryOperator = (typeof BINARY_OPERATORS)[number];
+export type UnaryOperator = (typeof UNARY_OPERATORS)[number];
+export type UnaryFilterOperator = (typeof UNARY_FILTER_OPERATORS)[number];
+export type Operator = (typeof OPERATORS)[number];
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';
     readonly operator: Operator;
@@ -26,3 +29,4 @@ export declare function isOperator(op: unknown): op is Operator;
 export declare function isBinaryOperator(op: unknown): op is BinaryOperator;
 export declare function isComparisonOperator(op: unknown): op is ComparisonOperator;
 export declare function isArithmeticOperator(op: unknown): op is ArithmeticOperator;
+export declare function isJSONOperator(op: unknown): op is JSONOperator;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArithmeticOperator = exports.isComparisonOperator = exports.isBinaryOperator = exports.isOperator = exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+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;
 const object_utils_js_1 = require("../util/object-utils.js");
 exports.COMPARISON_OPERATORS = [
     '=',
@@ -35,6 +35,7 @@ exports.COMPARISON_OPERATORS = [
     '@@@',
     '!!',
     '<->',
+    'regexp',
 ];
 exports.ARITHMETIC_OPERATORS = [
     '+',
@@ -49,6 +50,7 @@ exports.ARITHMETIC_OPERATORS = [
     '<<',
     '>>',
 ];
+exports.JSON_OPERATORS = ['->', '->>'];
 exports.BINARY_OPERATORS = [
     ...exports.COMPARISON_OPERATORS,
     ...exports.ARITHMETIC_OPERATORS,
@@ -57,7 +59,11 @@ exports.BINARY_OPERATORS = [
 ];
 exports.UNARY_FILTER_OPERATORS = ['exists', 'not exists'];
 exports.UNARY_OPERATORS = ['not', '-', ...exports.UNARY_FILTER_OPERATORS];
-exports.OPERATORS = [...exports.BINARY_OPERATORS, ...exports.UNARY_OPERATORS];
+exports.OPERATORS = [
+    ...exports.BINARY_OPERATORS,
+    ...exports.JSON_OPERATORS,
+    ...exports.UNARY_OPERATORS,
+];
 /**
  * @internal
  */
@@ -88,3 +94,7 @@ 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/query-node.d.ts

@@ -10,17 +10,17 @@ import { OperationNode } from './operation-node.js';
 import { ExplainNode } from './explain-node.js';
 import { ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
-export declare type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
-declare type HasJoins = {
+export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
+type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
 };
-declare type HasWhere = {
+type HasWhere = {
     where?: WhereNode;
 };
-declare type HasReturning = {
+type HasReturning = {
     returning?: ReturningNode;
 };
-declare type HasExplain = {
+type HasExplain = {
     explain?: ExplainNode;
 };
 /**
@@ -29,10 +29,9 @@ declare type HasExplain = {
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
-    cloneWithOrWhere<T_1 extends HasWhere>(node: T_1, operation: OperationNode): T_1;
-    cloneWithJoin<T_2 extends HasJoins>(node: T_2, join: JoinNode): T_2;
-    cloneWithReturning<T_3 extends HasReturning>(node: T_3, selections: ReadonlyArray<SelectionNode>): 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;
+    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;
+    cloneWithoutWhere<T_3 extends HasWhere>(node: T_3): T_3;
+    cloneWithExplain<T_4 extends HasExplain>(node: T_4, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_4;
 }>;
 export {};

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

@@ -27,14 +27,6 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
                 : where_node_js_1.WhereNode.create(operation),
         });
     },
-    cloneWithOrWhere(node, operation) {
-        return (0, object_utils_js_1.freeze)({
-            ...node,
-            where: node.where
-                ? where_node_js_1.WhereNode.cloneWithOperation(node.where, 'Or', operation)
-                : where_node_js_1.WhereNode.create(operation),
-        });
-    },
     cloneWithJoin(node, join) {
         return (0, object_utils_js_1.freeze)({
             ...node,

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

@@ -4,14 +4,14 @@ import { TableNode } from './table-node.js';
 import { SelectAllNode } from './select-all-node.js';
 export interface ReferenceNode extends OperationNode {
     readonly kind: 'ReferenceNode';
-    readonly table: TableNode;
     readonly column: ColumnNode | SelectAllNode;
+    readonly table?: TableNode;
 }
 /**
  * @internal
  */
 export declare const ReferenceNode: Readonly<{
     is(node: OperationNode): node is ReferenceNode;
-    create(table: TableNode, column: ColumnNode): ReferenceNode;
+    create(column: ColumnNode, table?: TableNode): ReferenceNode;
     createSelectAll(table: TableNode): ReferenceNode;
 }>;

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

@@ -10,7 +10,7 @@ exports.ReferenceNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'ReferenceNode';
     },
-    create(table, column) {
+    create(column, table) {
         return (0, object_utils_js_1.freeze)({
             kind: 'ReferenceNode',
             table,

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

@@ -3,7 +3,7 @@ import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
 import { ArrayItemType } from '../util/type-utils.js';
 export declare const ON_MODIFY_FOREIGN_ACTIONS: readonly ["no action", "restrict", "cascade", "set null", "set default"];
-export declare type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
+export type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;

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

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
+export type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
 export interface SelectModifierNode extends OperationNode {
     readonly kind: 'SelectModifierNode';
     readonly modifier?: SelectModifier;

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

@@ -47,7 +47,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;

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

@@ -88,14 +88,6 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : having_node_js_1.HavingNode.create(operation),
         });
     },
-    cloneWithOrHaving(selectNode, operation) {
-        return (0, object_utils_js_1.freeze)({
-            ...selectNode,
-            having: selectNode.having
-                ? having_node_js_1.HavingNode.cloneWithOperation(selectNode.having, 'Or', operation)
-                : having_node_js_1.HavingNode.create(operation),
-        });
-    },
     cloneWithSetOperation(selectNode, setOperation) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,

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

@@ -3,7 +3,7 @@ import { OperationNode } from './operation-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 = SimpleReferenceExpressionNode | AliasNode | SelectAllNode;
+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

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type SetOperator = 'union' | 'intersect' | 'except';
+export type SetOperator = 'union' | 'intersect' | 'except';
 export interface SetOperationNode extends OperationNode {
     kind: 'SetOperationNode';
     operator: SetOperator;

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

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

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

@@ -8,7 +8,7 @@ import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { FromNode } from './from-node.js';
 import { ExplainNode } from './explain-node.js';
-export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
+export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table: OperationNode;

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

@@ -1,7 +1,7 @@
 import { OperationNode } from './operation-node.js';
 import { PrimitiveValueListNode } from './primitive-value-list-node.js';
 import { ValueListNode } from './value-list-node.js';
-export declare type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
+export type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
 export interface ValuesNode extends OperationNode {
     readonly kind: 'ValuesNode';
     readonly values: ReadonlyArray<ValuesItemNode>;

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

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
-export declare type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
+export type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
 export interface WithNode extends OperationNode {
     readonly kind: 'WithNode';
     readonly expressions: ReadonlyArray<CommonTableExpressionNode>;

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

@@ -4,17 +4,14 @@ import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './refer
 import { ValueExpression, ValueExpressionOrList } from './value-parser.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> | null>;
-export declare type OperatorExpression = Operator | Expression<unknown>;
-export declare type BinaryOperatorExpression = BinaryOperator | Expression<unknown>;
-export declare type ComparisonOperatorExpression = ComparisonOperator | Expression<unknown>;
-export declare type ArithmeticOperatorExpression = ArithmeticOperator | Expression<unknown>;
+export type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
+export type OperatorExpression = Operator | Expression<unknown>;
+export type BinaryOperatorExpression = BinaryOperator | Expression<unknown>;
+export type ComparisonOperatorExpression = ComparisonOperator | Expression<unknown>;
+export type ArithmeticOperatorExpression = ArithmeticOperator | Expression<unknown>;
+export declare function parseFilter(args: any[]): OperationNode;
+export declare function parseValueBinaryOperationOrExpression(args: any[]): OperationNode;
 export declare function parseValueBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
-export declare function parseReferentialBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
-export declare function parseValueComparison(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseReferentialComparison(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: ReferenceExpression<any, any>): BinaryOperationNode;
-export declare function parseWhere(args: any[]): OperationNode;
-export declare function parseHaving(args: any[]): OperationNode;
-export declare function parseOn(args: any[]): OperationNode;
-export declare function parseWhen(args: any[]): OperationNode;
+export declare function parseReferentialBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;

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

@@ -1,80 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWhen = exports.parseOn = exports.parseHaving = exports.parseWhere = exports.parseReferentialComparison = exports.parseValueComparison = exports.parseReferentialBinaryOperation = exports.parseValueBinaryOperation = void 0;
+exports.parseReferentialBinaryOperation = exports.parseReferentialComparison = exports.parseValueBinaryOperation = exports.parseValueBinaryOperationOrExpression = exports.parseFilter = 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");
-const select_query_node_js_1 = require("../operation-node/select-query-node.js");
-const join_node_js_1 = require("../operation-node/join-node.js");
+const expression_js_1 = require("../expression/expression.js");
 const expression_builder_js_1 = require("../expression/expression-builder.js");
-const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
-const case_node_js_1 = require("../operation-node/case-node.js");
+function parseFilter(args) {
+    if (args.length > 1 && !isComparisonOperatorExpression(args[1])) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(args[1])}`);
+    }
+    return parseValueBinaryOperationOrExpression(args);
+}
+exports.parseFilter = parseFilter;
+function parseValueBinaryOperationOrExpression(args) {
+    if (args.length === 3) {
+        return parseValueBinaryOperation(args[0], args[1], args[2]);
+    }
+    else if (args.length === 1) {
+        return parseExpressionOrFactory(args[0]);
+    }
+    throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
+}
+exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
 function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
-    if (!(0, operator_node_js_1.isBinaryOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+    if (!isBinaryOperatorExpression(operator)) {
         throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
     }
-    if (isIsComparison(operator, rightOperand)) {
+    if (isIsOperator(operator) && isNullOrBoolean(rightOperand)) {
         return parseIs(leftOperand, operator, rightOperand);
     }
     return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(rightOperand));
 }
 exports.parseValueBinaryOperation = parseValueBinaryOperation;
-function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
-    if (!(0, operator_node_js_1.isBinaryOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
-        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
-    }
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(rightOperand));
-}
-exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
-function parseValueComparison(leftOperand, operator, rightOperand) {
-    if (!(0, operator_node_js_1.isComparisonOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
-        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
-    }
-    return parseValueBinaryOperation(leftOperand, operator, rightOperand);
-}
-exports.parseValueComparison = parseValueComparison;
 function parseReferentialComparison(leftOperand, operator, rightOperand) {
-    if (!(0, operator_node_js_1.isComparisonOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+    if (!isComparisonOperatorExpression(operator)) {
         throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
     }
     return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
 }
 exports.parseReferentialComparison = parseReferentialComparison;
-function parseWhere(args) {
-    return parseFilter('where', args);
-}
-exports.parseWhere = parseWhere;
-function parseHaving(args) {
-    return parseFilter('having', args);
+function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperatorExpression(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(rightOperand));
 }
-exports.parseHaving = parseHaving;
-function parseOn(args) {
-    return parseFilter('on', args);
+exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
+function isBinaryOperatorExpression(expr) {
+    return (0, operator_node_js_1.isBinaryOperator)(expr) || (0, expression_js_1.isExpression)(expr);
 }
-exports.parseOn = parseOn;
-function parseWhen(args) {
-    return parseFilter('when', args);
+function isComparisonOperatorExpression(expr) {
+    return (0, operator_node_js_1.isComparisonOperator)(expr) || (0, expression_js_1.isExpression)(expr);
 }
-exports.parseWhen = parseWhen;
-function parseFilter(type, args) {
-    if (args.length === 3) {
-        return parseValueComparison(args[0], args[1], args[2]);
-    }
-    if (args.length === 1) {
-        return parseOneArgFilterExpression(type, args[0]);
-    }
-    throw createFilterExpressionError(type, args);
+function isIsOperator(operator) {
+    return operator === 'is' || operator === 'is not';
 }
-function isIsComparison(operator, rightOperand) {
-    return ((operator === 'is' || operator === 'is not') &&
-        ((0, object_utils_js_1.isNull)(rightOperand) || (0, object_utils_js_1.isBoolean)(rightOperand)));
+function isNullOrBoolean(value) {
+    return (0, object_utils_js_1.isNull)(value) || (0, object_utils_js_1.isBoolean)(value);
 }
 function parseIs(leftOperand, operator, rightOperand) {
     return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), value_node_js_1.ValueNode.createImmediate(rightOperand));
@@ -88,78 +75,12 @@ function parseOperator(operator) {
     }
     throw new Error(`invalid operator ${JSON.stringify(operator)}`);
 }
-function parseOneArgFilterExpression(type, arg) {
+function parseExpressionOrFactory(arg) {
     if ((0, object_utils_js_1.isFunction)(arg)) {
-        if (type === 'when') {
-            throw new Error(`when method doesn't accept a callback as an argument`);
-        }
-        return CALLBACK_PARSERS[type](arg);
+        return arg((0, expression_builder_js_1.createExpressionBuilder)()).toOperationNode();
     }
     else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        const node = arg.toOperationNode();
-        if (raw_node_js_1.RawNode.is(node) ||
-            binary_operation_node_js_1.BinaryOperationNode.is(node) ||
-            unary_operation_node_js_1.UnaryOperationNode.is(node) ||
-            parens_node_js_1.ParensNode.is(node) ||
-            case_node_js_1.CaseNode.is(node)) {
-            return node;
-        }
-    }
-    else if (type === 'when') {
-        return value_node_js_1.ValueNode.create(arg);
+        return arg.toOperationNode();
     }
-    throw createFilterExpressionError(type, arg);
-}
-function createFilterExpressionError(type, args) {
-    return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+    return value_node_js_1.ValueNode.create(arg);
 }
-const CALLBACK_PARSERS = (0, object_utils_js_1.freeze)({
-    where(callback) {
-        // TODO: Remove this once the grouper overload is removed.
-        const whereBuilder = (0, parse_utils_js_1.createSelectQueryBuilder)();
-        const exprBuilder = (0, expression_builder_js_1.expressionBuilder)();
-        const res = callback(Object.assign(whereBuilder, exprBuilder));
-        const node = res.toOperationNode();
-        if (select_query_node_js_1.SelectQueryNode.is(node)) {
-            if (!node.where) {
-                throw new Error('no `where` methods called inside a group callback');
-            }
-            return parens_node_js_1.ParensNode.create(node.where.where);
-        }
-        else {
-            return node;
-        }
-    },
-    having(callback) {
-        // TODO: Remove this once the grouper overload is removed.
-        const havingBuilder = (0, parse_utils_js_1.createSelectQueryBuilder)();
-        const exprBuilder = (0, expression_builder_js_1.expressionBuilder)();
-        const res = callback(Object.assign(havingBuilder, exprBuilder));
-        const node = res.toOperationNode();
-        if (select_query_node_js_1.SelectQueryNode.is(node)) {
-            if (!node.having) {
-                throw new Error('no `having` methods called inside a group callback');
-            }
-            return parens_node_js_1.ParensNode.create(node.having.having);
-        }
-        else {
-            return node;
-        }
-    },
-    on(callback) {
-        // TODO: Remove this once the grouper overload is removed.
-        const onBuilder = (0, parse_utils_js_1.createJoinBuilder)('InnerJoin', 'table');
-        const exprBuilder = (0, expression_builder_js_1.expressionBuilder)();
-        const res = callback(Object.assign(onBuilder, exprBuilder));
-        const node = res.toOperationNode();
-        if (join_node_js_1.JoinNode.is(node)) {
-            if (!node.on) {
-                throw new Error('no `on` methods called inside a group callback');
-            }
-            return parens_node_js_1.ParensNode.create(node.on.on);
-        }
-        else {
-            return node;
-        }
-    },
-});

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

@@ -1,2 +1,2 @@
 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 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;

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

@@ -1,5 +1,5 @@
 import { Expression } from '../expression/expression.js';
 import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
-export declare type DataTypeExpression = ColumnDataType | Expression<any>;
+export type DataTypeExpression = ColumnDataType | Expression<any>;
 export declare function parseDataTypeExpression(dataType: DataTypeExpression): OperationNode;

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

@@ -1,4 +1,4 @@
 import { Expression } from '../expression/expression.js';
 import { OperationNode } from '../operation-node/operation-node.js';
-export declare type DefaultValueExpression = unknown | Expression<unknown>;
+export type DefaultValueExpression = unknown | Expression<unknown>;
 export declare function parseDefaultValueExpression(value: DefaultValueExpression): OperationNode;