kysely 0.23.5 → 0.24.1

package/dist/esm/migration/file-migration-provider.d.ts

@@ -22,8 +22,11 @@ export declare class FileMigrationProvider implements MigrationProvider {
      * Returns all migrations, old and new.
      *
      * For example if you have your migrations in a folder as separate files,
-     * you can use the {@link FileMigrationProvider} that implements this
-     * method to return all migrations in a folder.
+     * you can implement this method to return all migration in that folder
+     * as {@link Migration} objects.
+     *
+     * Kysely already has a built-in {@link FileMigrationProvider} for node.js
+     * that does exactly that.
      *
      * The keys of the returned object are migration names and values are the
      * migrations. The order of the migrations is determined by the alphabetical

package/dist/esm/migration/migrator.d.ts

@@ -258,8 +258,11 @@ export interface MigrationProvider {
      * Returns all migrations, old and new.
      *
      * For example if you have your migrations in a folder as separate files,
-     * you can use the {@link FileMigrationProvider} that implements this
-     * method to return all migrations in a folder.
+     * you can implement this method to return all migration in that folder
+     * as {@link Migration} objects.
+     *
+     * Kysely already has a built-in {@link FileMigrationProvider} for node.js
+     * that does exactly that.
      *
      * The keys of the returned object are migration names and values are the
      * migrations. The order of the migrations is determined by the alphabetical

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -1,13 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
-import { SelectAllNode } from './select-all-node.js';
+import { SelectionNode } from './selection-node.js';
 import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { WhereNode } from './where-node.js';
 declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: AggregateFunction;
-    readonly aggregated: SimpleReferenceExpressionNode | SelectAllNode;
+    readonly aggregated: SimpleReferenceExpressionNode | SelectionNode;
     readonly distinct?: boolean;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
@@ -17,7 +17,7 @@ export interface AggregateFunctionNode extends OperationNode {
  */
 export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: AggregateFunction, aggregated: SimpleReferenceExpressionNode | SelectAllNode): AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, aggregated: SimpleReferenceExpressionNode | SelectionNode): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;

package/dist/esm/operation-node/create-index-node.d.ts

@@ -2,6 +2,7 @@ import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { TableNode } from './table-node.js';
+import { WhereNode } from './where-node.js';
 export declare type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
 export declare type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
 export interface CreateIndexNode extends OperationNode {
@@ -12,6 +13,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly unique?: boolean;
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
+    readonly where?: WhereNode;
 }
 /**
  * @internal

package/dist/esm/operation-node/delete-query-node.d.ts

@@ -29,6 +29,5 @@ export declare const DeleteQueryNode: Readonly<{
     create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
-    cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

package/dist/esm/operation-node/delete-query-node.js

@@ -31,12 +31,6 @@ export const DeleteQueryNode = freeze({
             limit,
         });
     },
-    cloneWithExplain(deleteNode, explain) {
-        return freeze({
-            ...deleteNode,
-            explain,
-        });
-    },
     cloneWithUsing(deleteNode, tables) {
         return freeze({
             ...deleteNode,

package/dist/esm/operation-node/function-node.d.ts

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

package/dist/esm/operation-node/function-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./function-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const FunctionNode = freeze({
+    is(node) {
+        return node.kind === 'FunctionNode';
+    },
+    create(func, args) {
+        return freeze({
+            kind: 'FunctionNode',
+            func,
+            arguments: args,
+        });
+    },
+});

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

@@ -77,6 +77,7 @@ import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
+import { FunctionNode } from './function-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -183,6 +184,7 @@ export declare class OperationNodeTransformer {
     protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
     protected transformUsing(node: UsingNode): UsingNode;
+    protected transformFunction(node: FunctionNode): FunctionNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -111,6 +111,7 @@ export class OperationNodeTransformer {
         BinaryOperationNode: this.transformBinaryOperation.bind(this),
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
         UsingNode: this.transformUsing.bind(this),
+        FunctionNode: this.transformFunction.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -405,6 +406,7 @@ export class OperationNodeTransformer {
             unique: node.unique,
             using: this.transformNode(node.using),
             ifNotExists: node.ifNotExists,
+            where: this.transformNode(node.where),
         });
     }
     transformList(node) {
@@ -696,6 +698,13 @@ export class OperationNodeTransformer {
             tables: this.transformNodeList(node.tables),
         });
     }
+    transformFunction(node) {
+        return requireAllProps({
+            kind: 'FunctionNode',
+            func: node.func,
+            arguments: this.transformNodeList(node.arguments),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -77,6 +77,7 @@ import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
+import { FunctionNode } from './function-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -160,4 +161,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
     protected abstract visitUsing(node: UsingNode): void;
+    protected abstract visitFunction(node: FunctionNode): void;
 }

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

@@ -84,6 +84,7 @@ export class OperationNodeVisitor {
         BinaryOperationNode: this.visitBinaryOperation.bind(this),
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
         UsingNode: this.visitUsing.bind(this),
+        FunctionNode: this.visitFunction.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/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';
+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';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,9 +1,16 @@
 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", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->"];
+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 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 = ComparisonOperator | UnaryFilterOperator;
+export declare type Operator = typeof OPERATORS[number];
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';
     readonly operator: Operator;
@@ -15,3 +22,7 @@ export declare const OperatorNode: Readonly<{
     is(node: OperationNode): node is OperatorNode;
     create(operator: Operator): OperatorNode;
 }>;
+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;

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

@@ -1,5 +1,5 @@
 /// <reference types="./operator-node.d.ts" />
-import { freeze } from '../util/object-utils.js';
+import { freeze, isString } from '../util/object-utils.js';
 export const COMPARISON_OPERATORS = [
     '=',
     '==',
@@ -29,14 +29,33 @@ export const COMPARISON_OPERATORS = [
     '~',
     '~*',
     '!~*',
-    '&&',
-    '||',
     '@@',
     '@@@',
     '!!',
     '<->',
 ];
+export const ARITHMETIC_OPERATORS = [
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '^',
+    '&',
+    '|',
+    '#',
+    '<<',
+    '>>',
+];
+export const BINARY_OPERATORS = [
+    ...COMPARISON_OPERATORS,
+    ...ARITHMETIC_OPERATORS,
+    '&&',
+    '||',
+];
 export const UNARY_FILTER_OPERATORS = ['exists', 'not exists'];
+export const UNARY_OPERATORS = ['not', '-', ...UNARY_FILTER_OPERATORS];
+export const OPERATORS = [...BINARY_OPERATORS, ...UNARY_OPERATORS];
 /**
  * @internal
  */
@@ -51,3 +70,15 @@ export const OperatorNode = freeze({
         });
     },
 });
+export function isOperator(op) {
+    return isString(op) && OPERATORS.includes(op);
+}
+export function isBinaryOperator(op) {
+    return isString(op) && BINARY_OPERATORS.includes(op);
+}
+export function isComparisonOperator(op) {
+    return isString(op) && COMPARISON_OPERATORS.includes(op);
+}
+export function isArithmeticOperator(op) {
+    return isString(op) && ARITHMETIC_OPERATORS.includes(op);
+}

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

@@ -2,20 +2,37 @@ import { InsertQueryNode } from './insert-query-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { UpdateQueryNode } from './update-query-node.js';
 import { DeleteQueryNode } from './delete-query-node.js';
+import { WhereNode } from './where-node.js';
 import { JoinNode } from './join-node.js';
 import { SelectionNode } from './selection-node.js';
+import { ReturningNode } from './returning-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type QueryNode = SelectQueryNode | DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
-export declare type MutatingQueryNode = DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
-export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | UpdateQueryNode;
+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 = {
+    joins?: ReadonlyArray<JoinNode>;
+};
+declare type HasWhere = {
+    where?: WhereNode;
+};
+declare type HasReturning = {
+    returning?: ReturningNode;
+};
+declare type HasExplain = {
+    explain?: ExplainNode;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
-    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;
-    cloneWithoutWhere<T_4 extends FilterableQueryNode>(node: T_4): T_4;
+    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;
 }>;
+export {};

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

@@ -6,15 +6,16 @@ import { DeleteQueryNode } from './delete-query-node.js';
 import { WhereNode } from './where-node.js';
 import { freeze } from '../util/object-utils.js';
 import { ReturningNode } from './returning-node.js';
+import { ExplainNode } from './explain-node.js';
 /**
  * @internal
  */
 export const QueryNode = freeze({
     is(node) {
-        return (DeleteQueryNode.is(node) ||
+        return (SelectQueryNode.is(node) ||
             InsertQueryNode.is(node) ||
             UpdateQueryNode.is(node) ||
-            SelectQueryNode.is(node));
+            DeleteQueryNode.is(node));
     },
     cloneWithWhere(node, operation) {
         return freeze({
@@ -52,4 +53,10 @@ export const QueryNode = freeze({
             where: undefined,
         });
     },
+    cloneWithExplain(node, format, options) {
+        return freeze({
+            ...node,
+            explain: ExplainNode.create(format, options?.toOperationNode()),
+        });
+    },
 });

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

@@ -49,7 +49,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
-    cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;

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

@@ -102,12 +102,6 @@ export const SelectQueryNode = freeze({
                 : freeze([setOperation]),
         });
     },
-    cloneWithExplain(selectNode, explain) {
-        return freeze({
-            ...selectNode,
-            explain,
-        });
-    },
     cloneWithoutSelections(select) {
         return freeze({
             ...select,

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

@@ -28,5 +28,4 @@ export declare const UpdateQueryNode: Readonly<{
     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/esm/operation-node/update-query-node.js

@@ -31,10 +31,4 @@ export const UpdateQueryNode = freeze({
                 : updates,
         });
     },
-    cloneWithExplain(updateQuery, explain) {
-        return freeze({
-            ...updateQuery,
-            explain,
-        });
-    },
 });

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

@@ -1,20 +1,19 @@
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { ComparisonOperator } from '../operation-node/operator-node.js';
+import { ComparisonOperator, ArithmeticOperator, BinaryOperator, Operator } 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> | null>;
-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 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 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 parseReferentialFilter(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: ReferenceExpression<any, any>): BinaryOperationNode;
-export declare function parseFilterExpression(type: FilterExpressionType, args: any[]): OperationNode;
-export {};

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

@@ -3,55 +3,79 @@ import { BinaryOperationNode } from '../operation-node/binary-operation-node.js'
 import { freeze, isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { OperatorNode, COMPARISON_OPERATORS, } from '../operation-node/operator-node.js';
+import { OperatorNode, isComparisonOperator, isBinaryOperator, OPERATORS, } from '../operation-node/operator-node.js';
 import { ParensNode } from '../operation-node/parens-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
 import { parseValueExpressionOrList, } from './value-parser.js';
 import { ValueNode } from '../operation-node/value-node.js';
 import { createJoinBuilder, createSelectQueryBuilder } from './parse-utils.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { JoinNode } from '../operation-node/join-node.js';
+import { expressionBuilder } from '../expression/expression-builder.js';
+export function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    if (isIsComparison(operator, rightOperand)) {
+        return parseIs(leftOperand, operator, rightOperand);
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseValueExpressionOrList(rightOperand));
+}
+export function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseReferenceExpression(rightOperand));
+}
+export function parseValueComparison(leftOperand, operator, rightOperand) {
+    if (!isComparisonOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+    }
+    return parseValueBinaryOperation(leftOperand, operator, rightOperand);
+}
+export function parseReferentialComparison(leftOperand, operator, rightOperand) {
+    if (!isComparisonOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+    }
+    return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
+}
 export function parseWhere(args) {
-    return parseFilterExpression('where', args);
+    return parseFilter('where', args);
 }
 export function parseHaving(args) {
-    return parseFilterExpression('having', args);
+    return parseFilter('having', args);
 }
 export function parseOn(args) {
-    return parseFilterExpression('on', args);
+    return parseFilter('on', args);
 }
-export function parseReferentialFilter(leftOperand, operator, rightOperand) {
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), parseReferenceExpression(rightOperand));
-}
-export function parseFilterExpression(type, args) {
+function parseFilter(type, args) {
     if (args.length === 3) {
-        return parseFilter(args[0], args[1], args[2]);
+        return parseValueComparison(args[0], args[1], args[2]);
     }
     if (args.length === 1) {
         return parseOneArgFilterExpression(type, args[0]);
     }
     throw createFilterExpressionError(type, args);
 }
-function parseFilter(leftOperand, operator, rightOperand) {
-    if ((operator === 'is' || operator === 'is not') &&
-        (isNull(rightOperand) || isBoolean(rightOperand))) {
-        return parseIs(leftOperand, operator, rightOperand);
-    }
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), parseValueExpressionOrList(rightOperand));
+function isIsComparison(operator, rightOperand) {
+    return ((operator === 'is' || operator === 'is not') &&
+        (isNull(rightOperand) || isBoolean(rightOperand)));
 }
 function parseIs(leftOperand, operator, rightOperand) {
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), ValueNode.createImmediate(rightOperand));
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), ValueNode.createImmediate(rightOperand));
 }
-function parseComparisonOperatorExpression(operator) {
-    if (isString(operator) && COMPARISON_OPERATORS.includes(operator)) {
+function parseOperator(operator) {
+    if (isString(operator) && OPERATORS.includes(operator)) {
         return OperatorNode.create(operator);
     }
-    else if (isOperationNodeSource(operator)) {
+    if (isOperationNodeSource(operator)) {
         return operator.toOperationNode();
     }
-    throw new Error(`invalid comparison operator ${JSON.stringify(operator)} passed to a filter method`);
+    throw new Error(`invalid operator ${JSON.stringify(operator)}`);
 }
 function parseOneArgFilterExpression(type, arg) {
     if (isFunction(arg)) {
-        return GROUP_PARSERS[type](arg);
+        return CALLBACK_PARSERS[type](arg);
     }
     else if (isOperationNodeSource(arg)) {
         const node = arg.toOperationNode();
@@ -64,29 +88,53 @@ function parseOneArgFilterExpression(type, arg) {
 function createFilterExpressionError(type, args) {
     return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
 }
-const GROUP_PARSERS = freeze({
+const CALLBACK_PARSERS = freeze({
     where(callback) {
-        const query = callback(createSelectQueryBuilder());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.where) {
-            throw new Error('no `where` methods called inside a group callback');
+        // TODO: Remove this once the grouper overload is removed.
+        const whereBuilder = createSelectQueryBuilder();
+        const exprBuilder = expressionBuilder();
+        const res = callback(Object.assign(whereBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (SelectQueryNode.is(node)) {
+            if (!node.where) {
+                throw new Error('no `where` methods called inside a group callback');
+            }
+            return ParensNode.create(node.where.where);
+        }
+        else {
+            return node;
         }
-        return ParensNode.create(queryNode.where.where);
     },
     having(callback) {
-        const query = callback(createSelectQueryBuilder());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.having) {
-            throw new Error('no `having` methods called inside a group callback');
+        // TODO: Remove this once the grouper overload is removed.
+        const havingBuilder = createSelectQueryBuilder();
+        const exprBuilder = expressionBuilder();
+        const res = callback(Object.assign(havingBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (SelectQueryNode.is(node)) {
+            if (!node.having) {
+                throw new Error('no `having` methods called inside a group callback');
+            }
+            return ParensNode.create(node.having.having);
+        }
+        else {
+            return node;
         }
-        return ParensNode.create(queryNode.having.having);
     },
     on(callback) {
-        const joinBuilder = callback(createJoinBuilder('InnerJoin', 'table'));
-        const joinNode = joinBuilder.toOperationNode();
-        if (!joinNode.on) {
-            throw new Error('no `on` methods called inside a group callback');
+        // TODO: Remove this once the grouper overload is removed.
+        const onBuilder = createJoinBuilder('InnerJoin', 'table');
+        const exprBuilder = expressionBuilder();
+        const res = callback(Object.assign(onBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (JoinNode.is(node)) {
+            if (!node.on) {
+                throw new Error('no `on` methods called inside a group callback');
+            }
+            return ParensNode.create(node.on.on);
+        }
+        else {
+            return node;
         }
-        return ParensNode.create(joinNode.on.on);
     },
 });

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

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