kysely 0.22.0 → 0.23.0

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

@@ -6,7 +6,6 @@ import { JoinNode } from './join-node.js';
 import { LimitNode } from './limit-node.js';
 import { OffsetNode } from './offset-node.js';
 import { OperationNode } from './operation-node.js';
-import { FilterExpressionNode, TableExpressionNode } from './operation-node-utils.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
@@ -19,7 +18,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
-    readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
+    readonly distinctOn?: ReadonlyArray<OperationNode>;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
@@ -38,17 +37,17 @@ export interface SelectQueryNode extends OperationNode {
  */
 export declare const SelectQueryNode: Readonly<{
     is(node: OperationNode): node is SelectQueryNode;
-    create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode): SelectQueryNode;
+    create(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
-    cloneWithDistinctOnSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
+    cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItem(selectNode: SelectQueryNode, item: OrderByItemNode): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
 }>;

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

@@ -26,12 +26,12 @@ export const SelectQueryNode = freeze({
                 : freeze(selections),
         });
     },
-    cloneWithDistinctOnSelections(select, selections) {
+    cloneWithDistinctOn(select, expressions) {
         return freeze({
             ...select,
-            distinctOnSelections: select.distinctOnSelections
-                ? freeze([...select.distinctOnSelections, ...selections])
-                : freeze(selections),
+            distinctOn: select.distinctOn
+                ? freeze([...select.distinctOn, ...expressions])
+                : freeze(expressions),
         });
     },
     cloneWithFrontModifier(select, modifier) {
@@ -78,20 +78,20 @@ export const SelectQueryNode = freeze({
             offset,
         });
     },
-    cloneWithHaving(selectNode, filter) {
+    cloneWithHaving(selectNode, operation) {
         return freeze({
             ...selectNode,
             having: selectNode.having
-                ? HavingNode.cloneWithFilter(selectNode.having, 'And', filter)
-                : HavingNode.create(filter),
+                ? HavingNode.cloneWithOperation(selectNode.having, 'And', operation)
+                : HavingNode.create(operation),
         });
     },
-    cloneWithOrHaving(selectNode, filter) {
+    cloneWithOrHaving(selectNode, operation) {
         return freeze({
             ...selectNode,
             having: selectNode.having
-                ? HavingNode.cloneWithFilter(selectNode.having, 'Or', filter)
-                : HavingNode.create(filter),
+                ? HavingNode.cloneWithOperation(selectNode.having, 'Or', operation)
+                : HavingNode.create(operation),
         });
     },
     cloneWithSetOperation(selectNode, setOperation) {

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

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

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

@@ -1,12 +1,9 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { SelectQueryNode } from './select-query-node.js';
-export declare type SetOperationExpressionNode = SelectQueryNode | RawNode;
 export declare type SetOperator = 'union' | 'intersect' | 'except';
 export interface SetOperationNode extends OperationNode {
     kind: 'SetOperationNode';
     operator: SetOperator;
-    expression: SetOperationExpressionNode;
+    expression: OperationNode;
     all: boolean;
 }
 /**
@@ -14,5 +11,5 @@ export interface SetOperationNode extends OperationNode {
  */
 export declare const SetOperationNode: Readonly<{
     is(node: OperationNode): node is SetOperationNode;
-    create(operator: SetOperator, expression: SetOperationExpressionNode, all: boolean): SetOperationNode;
+    create(operator: SetOperator, expression: OperationNode, all: boolean): SetOperationNode;
 }>;

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

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

package/dist/esm/operation-node/simple-reference-expression-node.js

@@ -0,0 +1,2 @@
+/// <reference types="./simple-reference-expression-node.d.ts" />
+export {};

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

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

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

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

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

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

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

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

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

@@ -1,14 +1,13 @@
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface WhereNode extends OperationNode {
     readonly kind: 'WhereNode';
-    readonly where: FilterExpressionNode;
+    readonly where: OperationNode;
 }
 /**
  * @internal
  */
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
-    create(filter: FilterExpressionNode): WhereNode;
-    cloneWithFilter(whereNode: WhereNode, op: 'And' | 'Or', filter: FilterExpressionNode): WhereNode;
+    create(filter: OperationNode): WhereNode;
+    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): WhereNode;
 }>;

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

@@ -15,12 +15,12 @@ export const WhereNode = freeze({
             where: filter,
         });
     },
-    cloneWithFilter(whereNode, op, filter) {
+    cloneWithOperation(whereNode, operator, operation) {
         return freeze({
             ...whereNode,
-            where: op === 'And'
-                ? AndNode.create(whereNode.where, filter)
-                : OrNode.create(whereNode.where, filter),
+            where: operator === 'And'
+                ? AndNode.create(whereNode.where, operation)
+                : OrNode.create(whereNode.where, operation),
         });
     },
 });

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

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

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

@@ -0,0 +1,92 @@
+/// <reference types="./binary-operation-parser.d.ts" />
+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 { 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';
+export function parseWhere(args) {
+    return parseFilterExpression('where', args);
+}
+export function parseHaving(args) {
+    return parseFilterExpression('having', args);
+}
+export function parseOn(args) {
+    return parseFilterExpression('on', args);
+}
+export function parseReferentialFilter(leftOperand, operator, rightOperand) {
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), parseReferenceExpression(rightOperand));
+}
+export function parseFilterExpression(type, args) {
+    if (args.length === 3) {
+        return parseFilter(args[0], args[1], args[2]);
+    }
+    if (args.length === 1) {
+        return parseOneArgFilterExpression(type, args[0]);
+    }
+    throw createFilterExpressionError(type, args);
+}
+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 parseIs(leftOperand, operator, rightOperand) {
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), ValueNode.createImmediate(rightOperand));
+}
+function parseComparisonOperatorExpression(operator) {
+    if (isString(operator) && COMPARISON_OPERATORS.includes(operator)) {
+        return OperatorNode.create(operator);
+    }
+    else if (isOperationNodeSource(operator)) {
+        return operator.toOperationNode();
+    }
+    throw new Error(`invalid comparison operator ${JSON.stringify(operator)} passed to a filter method`);
+}
+function parseOneArgFilterExpression(type, arg) {
+    if (isFunction(arg)) {
+        return GROUP_PARSERS[type](arg);
+    }
+    else if (isOperationNodeSource(arg)) {
+        const node = arg.toOperationNode();
+        if (RawNode.is(node)) {
+            return node;
+        }
+    }
+    throw createFilterExpressionError(type, arg);
+}
+function createFilterExpressionError(type, args) {
+    return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+}
+const GROUP_PARSERS = 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');
+        }
+        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');
+        }
+        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');
+        }
+        return ParensNode.create(joinNode.on.on);
+    },
+});

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

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

package/dist/esm/parser/coalesce-parser.js

@@ -0,0 +1,8 @@
+/// <reference types="./coalesce-parser.d.ts" />
+import { RawNode } from '../operation-node/raw-node.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parseCoalesce(values) {
+    return RawNode.create(values.length > 1
+        ? ['coalesce(', ...new Array(values.length - 1).fill(', '), ')']
+        : ['coalesce(', ')'], parseReferenceExpressionOrList(values));
+}

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

@@ -1,5 +1,5 @@
-import { ColumnDataType, DataTypeNode } from '../operation-node/data-type-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
-export declare type DataTypeExpression = ColumnDataType | AnyRawBuilder;
-export declare function parseDataTypeExpression(dataType: DataTypeExpression): DataTypeNode | RawNode;
+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 declare function parseDataTypeExpression(dataType: DataTypeExpression): OperationNode;

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

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

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

@@ -1,8 +1,8 @@
 /// <reference types="./default-value-parser.d.ts" />
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
 export function parseDefaultValueExpression(value) {
-    return value instanceof RawBuilder
+    return isOperationNodeSource(value)
         ? value.toOperationNode()
         : ValueNode.createImmediate(value);
 }

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

@@ -0,0 +1,10 @@
+import { AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { ExpressionBuilder } from '../query-builder/expression-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+export declare type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, Record<string, V>> | ((eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, Record<string, V>>) | Expression<V> | ((eb: ExpressionBuilder<DB, TB>) => Expression<V>);
+export declare type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | ((qb: ExpressionBuilder<DB, TB>) => AliasedExpression<any, any>);
+export declare function parseExpression(exp: ExpressionOrFactory<any, any, any>): OperationNode;
+export declare function parseAliasedExpression(exp: AliasedExpressionOrFactory<any, any>): AliasNode;
+export declare function isExpressionOrFactory(obj: unknown): obj is ExpressionOrFactory<any, any, any>;

package/dist/esm/parser/{complex-expression-parser.js → expression-parser.js}

@@ -1,8 +1,9 @@
-/// <reference types="./complex-expression-parser.d.ts" />
+/// <reference types="./expression-parser.d.ts" />
+import { isExpression, } from '../expression/expression.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { isFunction } from '../util/object-utils.js';
 import { createExpressionBuilder } from './parse-utils.js';
-export function parseComplexExpression(exp) {
+export function parseExpression(exp) {
     if (isOperationNodeSource(exp)) {
         return exp.toOperationNode();
     }
@@ -11,7 +12,7 @@ export function parseComplexExpression(exp) {
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
-export function parseAliasedComplexExpression(exp) {
+export function parseAliasedExpression(exp) {
     if (isOperationNodeSource(exp)) {
         return exp.toOperationNode();
     }
@@ -20,6 +21,6 @@ export function parseAliasedComplexExpression(exp) {
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
-export function isComplexExpression(obj) {
-    return isOperationNodeSource(obj) || isFunction(obj);
+export function isExpressionOrFactory(obj) {
+    return isExpression(obj) || isFunction(obj);
 }

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

@@ -0,0 +1,2 @@
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
+export declare function parseSchemableIdentifier(id: string): SchemableIdentifierNode;

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

@@ -0,0 +1,20 @@
+/// <reference types="./identifier-parser.d.ts" />
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
+export function parseSchemableIdentifier(id) {
+    const SCHEMA_SEPARATOR = '.';
+    if (id.includes(SCHEMA_SEPARATOR)) {
+        const parts = id.split(SCHEMA_SEPARATOR).map(trim);
+        if (parts.length === 2) {
+            return SchemableIdentifierNode.createWithSchema(parts[0], parts[1]);
+        }
+        else {
+            throw new Error(`invalid schemable identifier ${id}`);
+        }
+    }
+    else {
+        return SchemableIdentifierNode.create(id);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

package/dist/esm/parser/insert-values-parser.d.ts

@@ -5,7 +5,7 @@ import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/c
 export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 } & {
-    [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
+    [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
 export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

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

@@ -5,7 +5,7 @@ import { ValueListNode } from '../operation-node/value-list-node.js';
 import { freeze, isUndefined } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
-import { isComplexExpression } from './complex-expression-parser.js';
+import { isExpressionOrFactory } from './expression-parser.js';
 import { DefaultInsertValueNode } from '../operation-node/default-insert-value-node.js';
 export function parseInsertObjectOrList(args) {
     return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
@@ -39,7 +39,7 @@ function parseRowValues(row, columns) {
         const columnIdx = columns.get(col);
         if (columnIdx !== undefined) {
             const value = row[col];
-            if (isComplexExpression(value)) {
+            if (isExpressionOrFactory(value)) {
                 complexColumn = true;
             }
             rowValues[columnIdx] = value;

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

@@ -1,7 +1,7 @@
 /// <reference types="./join-parser.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { parseTableExpression, } from './table-parser.js';
-import { parseReferenceFilter } from './filter-parser.js';
+import { parseReferentialFilter } from './binary-operation-parser.js';
 import { createJoinBuilder } from './parse-utils.js';
 export function parseJoin(joinType, args) {
     if (args.length === 3) {
@@ -19,5 +19,5 @@ function parseCallbackJoin(joinType, from, callback) {
     return joinBuilder.toOperationNode();
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
-    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferenceFilter(lhsColumn, '=', rhsColumn));
+    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialFilter(lhsColumn, '=', rhsColumn));
 }

package/dist/esm/parser/order-by-parser.d.ts

@@ -1,7 +1,7 @@
+import { Expression } from '../expression/expression.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';
 export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export declare type OrderByDirectionExpression = OrderByDirection | AnyRawBuilder;
+export declare type OrderByDirectionExpression = OrderByDirection | Expression<any>;
 export declare function parseOrderBy(orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

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

@@ -1,22 +1,22 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ReferenceNode } from '../operation-node/reference-node.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { ComplexExpression } from './complex-expression-parser.js';
+import { ExpressionOrFactory } from './expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
-import { AggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
-export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
-export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
+import { OperationNode } from '../operation-node/operation-node.js';
+import { Expression } from '../expression/expression.js';
+import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends AggregateFunctionBuilder<any, any, infer O> ? O : RE extends (qb: any) => AggregateFunctionBuilder<any, any, infer O> ? O : unknown;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : unknown;
-export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
-export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
-export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;
-export declare function parseAliasedStringReference(ref: string): ColumnNode | ReferenceNode | AliasNode;
+export declare type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
+export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
+export declare function parseSimpleReferenceExpression(exp: SimpleReferenceExpression<any, any>): SimpleReferenceExpressionNode;
+export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): OperationNode[];
+export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): OperationNode;
+export declare function parseStringReference(ref: string): SimpleReferenceExpressionNode;
+export declare function parseAliasedStringReference(ref: string): SimpleReferenceExpressionNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
-export {};

package/dist/esm/parser/reference-parser.js

@@ -4,9 +4,14 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
-import { parseComplexExpression, } from './complex-expression-parser.js';
-import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
+export function parseSimpleReferenceExpression(exp) {
+    if (isString(exp)) {
+        return parseStringReference(exp);
+    }
+    return exp.toOperationNode();
+}
 export function parseReferenceExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -16,13 +21,10 @@ export function parseReferenceExpressionOrList(arg) {
     }
 }
 export function parseReferenceExpression(exp) {
-    if (isString(exp)) {
-        return parseStringReference(exp);
-    }
-    else if (isDynamicReferenceBuilder(exp)) {
-        return exp.toOperationNode();
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
     }
-    return parseComplexExpression(exp);
+    return parseSimpleReferenceExpression(exp);
 }
 export function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';