kysely 0.21.6 → 0.23.0

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCoalesce = void 0;
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parseCoalesce(values) {
+    return raw_node_js_1.RawNode.create(values.length > 1
+        ? ['coalesce(', ...new Array(values.length - 1).fill(', '), ')']
+        : ['coalesce(', ')'], (0, reference_parser_js_1.parseReferenceExpressionOrList)(values));
+}
+exports.parseCoalesce = parseCoalesce;

package/dist/cjs/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/cjs/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/cjs/parser/default-value-parser.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDefaultValueExpression = void 0;
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
-const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 function parseDefaultValueExpression(value) {
-    return value instanceof raw_builder_js_1.RawBuilder
+    return (0, operation_node_source_js_1.isOperationNodeSource)(value)
         ? value.toOperationNode()
         : value_node_js_1.ValueNode.createImmediate(value);
 }

package/dist/cjs/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/cjs/parser/{complex-expression-parser.js → expression-parser.js}

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isComplexExpression = exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
+exports.isExpressionOrFactory = exports.parseAliasedExpression = exports.parseExpression = void 0;
+const expression_js_1 = require("../expression/expression.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const parse_utils_js_1 = require("./parse-utils.js");
-function parseComplexExpression(exp) {
+function parseExpression(exp) {
     if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
         return exp.toOperationNode();
     }
@@ -13,8 +14,8 @@ function parseComplexExpression(exp) {
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
-exports.parseComplexExpression = parseComplexExpression;
-function parseAliasedComplexExpression(exp) {
+exports.parseExpression = parseExpression;
+function parseAliasedExpression(exp) {
     if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
         return exp.toOperationNode();
     }
@@ -23,8 +24,8 @@ function parseAliasedComplexExpression(exp) {
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
-exports.parseAliasedComplexExpression = parseAliasedComplexExpression;
-function isComplexExpression(obj) {
-    return (0, operation_node_source_js_1.isOperationNodeSource)(obj) || (0, object_utils_js_1.isFunction)(obj);
+exports.parseAliasedExpression = parseAliasedExpression;
+function isExpressionOrFactory(obj) {
+    return (0, expression_js_1.isExpression)(obj) || (0, object_utils_js_1.isFunction)(obj);
 }
-exports.isComplexExpression = isComplexExpression;
+exports.isExpressionOrFactory = isExpressionOrFactory;

package/dist/cjs/parser/group-by-parser.d.ts

@@ -2,4 +2,4 @@ import { GroupByItemNode } from '../operation-node/group-by-item-node.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 GroupByExpressionOrList<DB, TB extends keyof DB, O> = ReadonlyArray<GroupByExpression<DB, TB, O>> | GroupByExpression<DB, TB, O>;
-export declare function parseGroupBy(orderBy: GroupByExpressionOrList<any, any, any>): GroupByItemNode[];
+export declare function parseGroupBy(groupBy: GroupByExpressionOrList<any, any, any>): GroupByItemNode[];

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGroupBy = void 0;
 const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
-function parseGroupBy(orderBy) {
-    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
+function parseGroupBy(groupBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(groupBy).map(group_by_item_node_js_1.GroupByItemNode.create);
 }
 exports.parseGroupBy = parseGroupBy;

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchemableIdentifier = void 0;
+const schemable_identifier_node_js_1 = require("../operation-node/schemable-identifier-node.js");
+function parseSchemableIdentifier(id) {
+    const SCHEMA_SEPARATOR = '.';
+    if (id.includes(SCHEMA_SEPARATOR)) {
+        const parts = id.split(SCHEMA_SEPARATOR).map(trim);
+        if (parts.length === 2) {
+            return schemable_identifier_node_js_1.SchemableIdentifierNode.createWithSchema(parts[0], parts[1]);
+        }
+        else {
+            throw new Error(`invalid schemable identifier ${id}`);
+        }
+    }
+    else {
+        return schemable_identifier_node_js_1.SchemableIdentifierNode.create(id);
+    }
+}
+exports.parseSchemableIdentifier = parseSchemableIdentifier;
+function trim(str) {
+    return str.trim();
+}

package/dist/cjs/parser/insert-values-parser.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/cjs/parser/insert-values-parser.js

@@ -7,7 +7,7 @@ const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 const default_insert_value_node_js_1 = require("../operation-node/default-insert-value-node.js");
 function parseInsertObjectOrList(args) {
     return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
@@ -42,7 +42,7 @@ function parseRowValues(row, columns) {
         const columnIdx = columns.get(col);
         if (columnIdx !== undefined) {
             const value = row[col];
-            if ((0, complex_expression_parser_js_1.isComplexExpression)(value)) {
+            if ((0, expression_parser_js_1.isExpressionOrFactory)(value)) {
                 complexColumn = true;
             }
             rowValues[columnIdx] = value;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJoin = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const table_parser_js_1 = require("./table-parser.js");
-const filter_parser_js_1 = require("./filter-parser.js");
+const binary_operation_parser_js_1 = require("./binary-operation-parser.js");
 const parse_utils_js_1 = require("./parse-utils.js");
 function parseJoin(joinType, args) {
     if (args.length === 3) {
@@ -22,5 +22,5 @@ function parseCallbackJoin(joinType, from, callback) {
     return joinBuilder.toOperationNode();
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
-    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(from), (0, filter_parser_js_1.parseReferenceFilter)(lhsColumn, '=', rhsColumn));
+    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(from), (0, binary_operation_parser_js_1.parseReferentialFilter)(lhsColumn, '=', rhsColumn));
 }

package/dist/cjs/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/cjs/parser/parse-utils.d.ts

@@ -1,6 +1,7 @@
 import { JoinType } from '../operation-node/join-node.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { TableExpression } from './table-parser.js';
@@ -8,3 +9,4 @@ export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any,
 export declare function createExpressionBuilder(): ExpressionBuilder<any, any>;
 export declare function createQueryCreator(): QueryCreator<any>;
 export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+export declare function createOverBuilder(): OverBuilder<any, any>;

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJoinBuilder = exports.createQueryCreator = exports.createExpressionBuilder = exports.createSelectQueryBuilder = void 0;
+exports.createOverBuilder = exports.createJoinBuilder = exports.createQueryCreator = exports.createExpressionBuilder = exports.createSelectQueryBuilder = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
+const over_node_js_1 = require("../operation-node/over-node.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const expression_builder_js_1 = require("../query-builder/expression-builder.js");
 const join_builder_js_1 = require("../query-builder/join-builder.js");
+const over_builder_js_1 = require("../query-builder/over-builder.js");
 const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
 const query_creator_js_1 = require("../query-creator.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
@@ -36,3 +38,9 @@ function createJoinBuilder(joinType, table) {
     });
 }
 exports.createJoinBuilder = createJoinBuilder;
+function createOverBuilder() {
+    return new over_builder_js_1.OverBuilder({
+        overNode: over_node_js_1.OverNode.create(),
+    });
+}
+exports.createOverBuilder = createOverBuilder;

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

@@ -0,0 +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 declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePartitionBy = void 0;
+const partition_by_item_node_js_1 = require("../operation-node/partition-by-item-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parsePartitionBy(partitionBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(partitionBy).map(partition_by_item_node_js_1.PartitionByItemNode.create);
+}
+exports.parsePartitionBy = parsePartitionBy;

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

@@ -1,21 +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';
-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> : 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/cjs/parser/reference-parser.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseColumnName = exports.parseAliasedStringReference = exports.parseStringReference = exports.parseReferenceExpression = exports.parseReferenceExpressionOrList = void 0;
+exports.parseColumnName = exports.parseAliasedStringReference = exports.parseStringReference = exports.parseReferenceExpression = exports.parseReferenceExpressionOrList = exports.parseSimpleReferenceExpression = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
 const reference_node_js_1 = require("../operation-node/reference-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
-const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+function parseSimpleReferenceExpression(exp) {
+    if ((0, object_utils_js_1.isString)(exp)) {
+        return parseStringReference(exp);
+    }
+    return exp.toOperationNode();
+}
+exports.parseSimpleReferenceExpression = parseSimpleReferenceExpression;
 function parseReferenceExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -19,13 +25,10 @@ function parseReferenceExpressionOrList(arg) {
 }
 exports.parseReferenceExpressionOrList = parseReferenceExpressionOrList;
 function parseReferenceExpression(exp) {
-    if ((0, object_utils_js_1.isString)(exp)) {
-        return parseStringReference(exp);
-    }
-    else if ((0, dynamic_reference_builder_js_1.isDynamicReferenceBuilder)(exp)) {
-        return exp.toOperationNode();
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
+        return (0, expression_parser_js_1.parseExpression)(exp);
     }
-    return (0, complex_expression_parser_js_1.parseComplexExpression)(exp);
+    return parseSimpleReferenceExpression(exp);
 }
 exports.parseReferenceExpression = parseReferenceExpression;
 function parseStringReference(ref) {

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

@@ -1,11 +1,11 @@
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { AliasedSelectQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { AliasedComplexExpression } from './complex-expression-parser.js';
+import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
+import { AliasedExpression } from '../expression/expression.js';
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
  * Given a selection expression returns a query builder type that
@@ -19,9 +19,9 @@ export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends
 export declare type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
-declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
+declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
+declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
 declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {

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

@@ -5,7 +5,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const selection_node_js_1 = require("../operation-node/selection-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 const table_parser_js_1 = require("./table-parser.js");
 function parseSelectExpressionOrList(selection) {
     if ((0, object_utils_js_1.isReadonlyArray)(selection)) {
@@ -24,7 +24,7 @@ function parseSelectExpression(selection) {
         return selection_node_js_1.SelectionNode.create(selection.toOperationNode());
     }
     else {
-        return selection_node_js_1.SelectionNode.create((0, complex_expression_parser_js_1.parseAliasedComplexExpression)(selection));
+        return selection_node_js_1.SelectionNode.create((0, expression_parser_js_1.parseAliasedExpression)(selection));
     }
 }
 function parseSelectAll(table) {

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

@@ -0,0 +1,3 @@
+import { Expression } from '../expression/expression.js';
+import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
+export declare function parseSetOperation(operator: SetOperator, expression: Expression<any>, all: boolean): SetOperationNode;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSetOperation = void 0;
+const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
+function parseSetOperation(operator, expression, all) {
+    return set_operation_node_js_1.SetOperationNode.create(operator, expression.toOperationNode(), all);
+}
+exports.parseSetOperation = parseSetOperation;

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

@@ -1,22 +1,21 @@
-import { AliasedQueryBuilder } from '../query-builder/select-query-builder.js';
+import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AnyAliasedRawBuilder } from '../util/type-utils.js';
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
-import { AliasedComplexExpression } from './complex-expression-parser.js';
-export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<DB, TB>;
+import { AliasedExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { AliasedExpression } from '../expression/expression.js';
+export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
-export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AnyAliasedRawBuilder;
+export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
 export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
-declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
-declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
+declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
 declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
-export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): TableExpressionNode[];
-export declare function parseTableExpression(table: TableExpression<any, any>): TableExpressionNode;
-export declare function parseAliasedTable(from: string): TableExpressionNode;
+export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
+export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
+export declare function parseAliasedTable(from: string): TableNode | AliasNode;
 export declare function parseTable(from: string): TableNode;
 export {};

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

@@ -4,7 +4,7 @@ exports.parseTable = exports.parseAliasedTable = exports.parseTableExpression =
 const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 function parseTableExpressionOrList(table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
@@ -20,7 +20,7 @@ function parseTableExpression(table) {
         return parseAliasedTable(table);
     }
     else {
-        return (0, complex_expression_parser_js_1.parseAliasedComplexExpression)(table);
+        return (0, expression_parser_js_1.parseAliasedExpression)(table);
     }
 }
 exports.parseTableExpression = parseTableExpression;

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

@@ -0,0 +1,5 @@
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { ExpressionOrFactory } from './expression-parser.js';
+export declare type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
+export declare function parseExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(arg: ExistsExpression<any, any>): UnaryOperationNode;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNotExists = exports.parseExists = void 0;
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
+const value_parser_js_1 = require("./value-parser.js");
+function parseExists(arg) {
+    return parseUnaryOperation('exists', arg);
+}
+exports.parseExists = parseExists;
+function parseNotExists(arg) {
+    return parseUnaryOperation('not exists', arg);
+}
+exports.parseNotExists = parseNotExists;
+function parseUnaryOperation(type, arg) {
+    return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(arg));
+}

package/dist/cjs/parser/update-set-parser.d.ts

@@ -2,6 +2,6 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB, TM extends keyof DB> = {
-    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>>;
+    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>> | undefined;
 };
 export declare function parseUpdateObject(row: MutationObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

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

@@ -1,9 +1,6 @@
-import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { ComplexExpression } from './complex-expression-parser.js';
-export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB, V>;
+import { ExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;

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

@@ -5,7 +5,7 @@ const primitive_value_list_node_js_1 = require("../operation-node/primitive-valu
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 function parseValueExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return parseValueExpressionList(arg);
@@ -16,14 +16,14 @@ function parseValueExpressionOrList(arg) {
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(exp) {
-    if ((0, complex_expression_parser_js_1.isComplexExpression)(exp)) {
-        return (0, complex_expression_parser_js_1.parseComplexExpression)(exp);
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
+        return (0, expression_parser_js_1.parseExpression)(exp);
     }
     return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(arg) {
-    if (arg.some(complex_expression_parser_js_1.isComplexExpression)) {
+    if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
         return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));
     }
     return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);

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

@@ -1,21 +1,20 @@
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
 import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
 import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Expression } from '../expression/expression.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -111,5 +111,5 @@ class CamelCasePlugin {
 }
 exports.CamelCasePlugin = CamelCasePlugin;
 function canMap(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj);
+    return ((0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj) && !(0, object_utils_js_1.isArrayBufferOrView)(obj));
 }