kysely 0.24.2 → 0.26.0

package/dist/esm/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/esm/operation-node/select-query-node.js

@@ -86,14 +86,6 @@ export const SelectQueryNode = freeze({
                 : HavingNode.create(operation),
         });
     },
-    cloneWithOrHaving(selectNode, operation) {
-        return freeze({
-            ...selectNode,
-            having: selectNode.having
-                ? HavingNode.cloneWithOperation(selectNode.having, 'Or', operation)
-                : HavingNode.create(operation),
-        });
-    },
     cloneWithSetOperation(selectNode, setOperation) {
         return freeze({
             ...selectNode,

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/operation-node/when-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export interface WhenNode extends OperationNode {
+    readonly kind: 'WhenNode';
+    readonly condition: OperationNode;
+    readonly result?: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const WhenNode: Readonly<{
+    is(node: OperationNode): node is WhenNode;
+    create(condition: OperationNode): WhenNode;
+    cloneWithResult(whenNode: WhenNode, result: OperationNode): WhenNode;
+}>;

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

@@ -0,0 +1,22 @@
+/// <reference types="./when-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const WhenNode = freeze({
+    is(node) {
+        return node.kind === 'WhenNode';
+    },
+    create(condition) {
+        return freeze({
+            kind: 'WhenNode',
+            condition,
+        });
+    },
+    cloneWithResult(whenNode, result) {
+        return freeze({
+            ...whenNode,
+            result,
+        });
+    },
+});

package/dist/esm/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/esm/parser/binary-operation-parser.d.ts

@@ -4,16 +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 parseReferentialBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;

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

@@ -1,65 +1,60 @@
 /// <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 { 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, 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)}`);
+import { isExpression } from '../expression/expression.js';
+import { createExpressionBuilder } from '../expression/expression-builder.js';
+export function parseFilter(args) {
+    if (args.length > 1 && !isComparisonOperatorExpression(args[1])) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(args[1])}`);
     }
-    if (isIsComparison(operator, rightOperand)) {
-        return parseIs(leftOperand, operator, rightOperand);
+    return parseValueBinaryOperationOrExpression(args);
+}
+export function parseValueBinaryOperationOrExpression(args) {
+    if (args.length === 3) {
+        return parseValueBinaryOperation(args[0], args[1], args[2]);
     }
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseValueExpressionOrList(rightOperand));
+    else if (args.length === 1) {
+        return parseExpressionOrFactory(args[0]);
+    }
+    throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
 }
-export function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
-    if (!isBinaryOperator(operator) && !isOperationNodeSource(operator)) {
+export function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperatorExpression(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)}`);
+    if (isIsOperator(operator) && isNullOrBoolean(rightOperand)) {
+        return parseIs(leftOperand, operator, rightOperand);
     }
-    return parseValueBinaryOperation(leftOperand, operator, rightOperand);
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseValueExpressionOrList(rightOperand));
 }
 export function parseReferentialComparison(leftOperand, operator, rightOperand) {
-    if (!isComparisonOperator(operator) && !isOperationNodeSource(operator)) {
+    if (!isComparisonOperatorExpression(operator)) {
         throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
     }
     return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
 }
-export function parseWhere(args) {
-    return parseFilter('where', args);
+export function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperatorExpression(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseReferenceExpression(rightOperand));
 }
-export function parseHaving(args) {
-    return parseFilter('having', args);
+function isBinaryOperatorExpression(expr) {
+    return isBinaryOperator(expr) || isExpression(expr);
 }
-export function parseOn(args) {
-    return parseFilter('on', args);
+function isComparisonOperatorExpression(expr) {
+    return isComparisonOperator(expr) || isExpression(expr);
 }
-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') &&
-        (isNull(rightOperand) || isBoolean(rightOperand)));
+function isNullOrBoolean(value) {
+    return isNull(value) || isBoolean(value);
 }
 function parseIs(leftOperand, operator, rightOperand) {
     return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), ValueNode.createImmediate(rightOperand));
@@ -73,68 +68,12 @@ function parseOperator(operator) {
     }
     throw new Error(`invalid operator ${JSON.stringify(operator)}`);
 }
-function parseOneArgFilterExpression(type, arg) {
+function parseExpressionOrFactory(arg) {
     if (isFunction(arg)) {
-        return CALLBACK_PARSERS[type](arg);
+        return arg(createExpressionBuilder()).toOperationNode();
     }
     else if (isOperationNodeSource(arg)) {
-        const node = arg.toOperationNode();
-        if (RawNode.is(node)) {
-            return node;
-        }
+        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 ValueNode.create(arg);
 }
-const CALLBACK_PARSERS = freeze({
-    where(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;
-        }
-    },
-    having(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;
-        }
-    },
-    on(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;
-        }
-    },
-});

package/dist/esm/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/esm/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/esm/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;

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

@@ -3,11 +3,12 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { ExpressionBuilder } from '../expression/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>> | SelectQueryBuilderFactory<DB, TB, Record<string, V>> | Expression<V> | ExpressionFactory<DB, TB, V>;
-export declare type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
-declare type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, V>;
-declare type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
-declare type AliasedExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => AliasedExpression<any, any>;
+import { ShallowRecord } from '../util/type-utils.js';
+export type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, ShallowRecord<string, V>> | SelectQueryBuilderFactory<DB, TB, ShallowRecord<string, V>> | Expression<V> | ExpressionFactory<DB, TB, V>;
+export type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
+type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, V>;
+type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
+type AliasedExpressionFactory<DB, TB extends keyof DB> = (eb: 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/group-by-parser.d.ts

@@ -1,6 +1,6 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { ReferenceExpression } from './reference-parser.js';
-export declare type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export declare type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
+export type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
 export declare function parseGroupBy(groupBy: GroupByArg<any, any, any>): GroupByItemNode[];

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

@@ -3,12 +3,12 @@ import { ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
-export declare type InsertObject<DB, TB extends keyof DB> = {
+export 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]>> | undefined;
 };
-export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export declare type InsertObjectOrListFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => InsertObjectOrList<DB, TB>;
-export declare type InsertExpression<DB, TB extends keyof DB> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB>;
+export type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
+export type InsertObjectOrListFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => InsertObjectOrList<DB, TB>;
+export type InsertExpression<DB, TB extends keyof DB> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB>;
 export declare function parseInsertExpression(arg: InsertExpression<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

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

@@ -2,9 +2,9 @@ import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
 import { From, FromTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
+export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
+export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
+type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
+type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
 export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
 export {};

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

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

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

@@ -2,6 +2,9 @@
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
+export function isOrderByDirection(thing) {
+    return thing === 'asc' || thing === 'desc';
+}
 export function parseOrderBy(orderBy, direction) {
     return OrderByItemNode.create(parseOrderByExpression(orderBy), parseOrderByDirectionExpression(direction));
 }

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

@@ -1,6 +1,6 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
 import { StringReference } from './reference-parser.js';
-export declare type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
-export declare type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
+export type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
 export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

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

@@ -1,6 +1,7 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
@@ -8,15 +9,22 @@ import { SelectType } from '../util/column-type.js';
 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 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;
+import { OrderByDirection } from './order-by-parser.js';
+import { JSONOperatorWith$ } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
+export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
+export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
+export 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> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export 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 type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
+export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;
 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 parseJSONReference(ref: string, op: JSONOperatorWith$): JSONReferenceNode;
+export declare function parseStringReference(ref: string): ReferenceNode;
 export declare function parseAliasedStringReference(ref: string): SimpleReferenceExpressionNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
+export declare function parseOrderedColumnName(column: string): OperationNode;

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

@@ -6,6 +6,11 @@ import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOrderByDirection, parseOrderBy, } from './order-by-parser.js';
+import { OperatorNode, isJSONOperator, } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
 export function parseSimpleReferenceExpression(exp) {
     if (isString(exp)) {
         return parseStringReference(exp);
@@ -26,23 +31,30 @@ export function parseReferenceExpression(exp) {
     }
     return parseSimpleReferenceExpression(exp);
 }
+export function parseJSONReference(ref, op) {
+    const referenceNode = parseStringReference(ref);
+    if (isJSONOperator(op)) {
+        return JSONReferenceNode.create(referenceNode, JSONOperatorChainNode.create(OperatorNode.create(op)));
+    }
+    const opWithoutLastChar = op.slice(0, -1);
+    if (isJSONOperator(opWithoutLastChar)) {
+        return JSONReferenceNode.create(referenceNode, JSONPathNode.create(OperatorNode.create(opWithoutLastChar)));
+    }
+    throw new Error(`Invalid JSON operator: ${op}`);
+}
 export function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';
-    if (ref.includes(COLUMN_SEPARATOR)) {
-        const parts = ref.split(COLUMN_SEPARATOR).map(trim);
-        if (parts.length === 3) {
-            return parseStringReferenceWithTableAndSchema(parts);
-        }
-        else if (parts.length === 2) {
-            return parseStringReferenceWithTable(parts);
-        }
-        else {
-            throw new Error(`invalid column reference ${ref}`);
-        }
+    if (!ref.includes(COLUMN_SEPARATOR)) {
+        return ReferenceNode.create(ColumnNode.create(ref));
     }
-    else {
-        return ColumnNode.create(ref);
+    const parts = ref.split(COLUMN_SEPARATOR).map(trim);
+    if (parts.length === 3) {
+        return parseStringReferenceWithTableAndSchema(parts);
     }
+    if (parts.length === 2) {
+        return parseStringReferenceWithTable(parts);
+    }
+    throw new Error(`invalid column reference ${ref}`);
 }
 export function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
@@ -57,13 +69,26 @@ export function parseAliasedStringReference(ref) {
 export function parseColumnName(column) {
     return ColumnNode.create(column);
 }
+export function parseOrderedColumnName(column) {
+    const ORDER_SEPARATOR = ' ';
+    if (column.includes(ORDER_SEPARATOR)) {
+        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
+        if (!isOrderByDirection(order)) {
+            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
+        }
+        return parseOrderBy(columnName, order);
+    }
+    else {
+        return parseColumnName(column);
+    }
+}
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
-    return ReferenceNode.create(TableNode.createWithSchema(schema, table), ColumnNode.create(column));
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.createWithSchema(schema, table));
 }
 function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
-    return ReferenceNode.create(TableNode.create(table), ColumnNode.create(column));
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
 }
 function trim(str) {
     return str.trim();

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

@@ -2,5 +2,5 @@ import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection, AllSelection } from './select-parser.js';
-export declare type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
-export declare type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;
+export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;