kysely 0.16.9 → 0.17.1

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

@@ -10,48 +10,49 @@ const parens_node_js_1 = require("../operation-node/parens-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 const value_parser_js_1 = require("./value-parser.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
-function parseWhereFilter(ctx, args) {
-    return parseFilter(ctx, 'where', args);
+const parse_utils_js_1 = require("./parse-utils.js");
+function parseWhereFilter(args) {
+    return parseFilter('where', args);
 }
 exports.parseWhereFilter = parseWhereFilter;
-function parseHavingFilter(ctx, args) {
-    return parseFilter(ctx, 'having', args);
+function parseHavingFilter(args) {
+    return parseFilter('having', args);
 }
 exports.parseHavingFilter = parseHavingFilter;
-function parseOnFilter(ctx, args) {
-    return parseFilter(ctx, 'on', args);
+function parseOnFilter(args) {
+    return parseFilter('on', args);
 }
 exports.parseOnFilter = parseOnFilter;
-function parseReferenceFilter(ctx, lhs, op, rhs) {
-    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, lhs), parseFilterOperator(op), (0, reference_parser_js_1.parseReferenceExpression)(ctx, rhs));
+function parseReferenceFilter(lhs, op, rhs) {
+    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(lhs), parseFilterOperator(op), (0, reference_parser_js_1.parseReferenceExpression)(rhs));
 }
 exports.parseReferenceFilter = parseReferenceFilter;
-function parseExistFilter(ctx, arg) {
-    return parseExistExpression(ctx, 'exists', arg);
+function parseExistFilter(arg) {
+    return parseExistExpression('exists', arg);
 }
 exports.parseExistFilter = parseExistFilter;
-function parseNotExistFilter(ctx, arg) {
-    return parseExistExpression(ctx, 'not exists', arg);
+function parseNotExistFilter(arg) {
+    return parseExistExpression('not exists', arg);
 }
 exports.parseNotExistFilter = parseNotExistFilter;
-function parseFilter(ctx, type, args) {
+function parseFilter(type, args) {
     if (args.length === 3) {
-        return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
+        return parseThreeArgFilter(args[0], args[1], args[2]);
     }
     else if (args.length === 1) {
-        return parseOneArgFilter(ctx, type, args[0]);
+        return parseOneArgFilter(type, args[0]);
     }
     throw createFilterError(type, args);
 }
 exports.parseFilter = parseFilter;
-function parseThreeArgFilter(ctx, left, op, right) {
+function parseThreeArgFilter(left, op, right) {
     if ((op === 'is' || op === 'is not') && ((0, object_utils_js_1.isNull)(right) || (0, object_utils_js_1.isBoolean)(right))) {
-        return parseIsFilter(ctx, left, op, right);
+        return parseIsFilter(left, op, right);
     }
-    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, left), parseFilterOperator(op), (0, value_parser_js_1.parseValueExpressionOrList)(ctx, right));
+    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseFilterOperator(op), (0, value_parser_js_1.parseValueExpressionOrList)(right));
 }
-function parseIsFilter(ctx, left, op, right) {
-    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, left), parseFilterOperator(op), value_node_js_1.ValueNode.createImmediate(right));
+function parseIsFilter(left, op, right) {
+    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseFilterOperator(op), value_node_js_1.ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
     if ((0, object_utils_js_1.isString)(op) && operator_node_js_1.OPERATORS.includes(op)) {
@@ -62,12 +63,12 @@ function parseFilterOperator(op) {
     }
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
-function parseExistExpression(ctx, type, arg) {
-    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(ctx, arg));
+function parseExistExpression(type, arg) {
+    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(arg));
 }
-function parseOneArgFilter(ctx, type, arg) {
+function parseOneArgFilter(type, arg) {
     if ((0, object_utils_js_1.isFunction)(arg)) {
-        return GROUP_PARSERS[type](ctx, arg);
+        return GROUP_PARSERS[type](arg);
     }
     else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
         const node = arg.toOperationNode();
@@ -81,24 +82,24 @@ function createFilterError(type, args) {
     return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
 }
 const GROUP_PARSERS = (0, object_utils_js_1.freeze)({
-    where(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder());
+    where(callback) {
+        const query = callback((0, parse_utils_js_1.createSelectQueryBuilder)());
         const queryNode = query.toOperationNode();
         if (!queryNode.where) {
             throw new Error('no `where` methods called insided a group callback');
         }
         return parens_node_js_1.ParensNode.create(queryNode.where.where);
     },
-    having(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder());
+    having(callback) {
+        const query = callback((0, parse_utils_js_1.createSelectQueryBuilder)());
         const queryNode = query.toOperationNode();
         if (!queryNode.having) {
             throw new Error('no `having` methods called insided a group callback');
         }
         return parens_node_js_1.ParensNode.create(queryNode.having.having);
     },
-    on(ctx, callback) {
-        const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
+    on(callback) {
+        const joinBuilder = callback((0, parse_utils_js_1.createJoinBuilder)('InnerJoin', 'table'));
         const joinNode = joinBuilder.toOperationNode();
         if (!joinNode.on) {
             throw new Error('no `on` methods called insided a group callback');

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

@@ -1,4 +1,3 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
-import { ParseContext } from './parse-context.js';
 import { ReferenceExpressionOrList } from './reference-parser.js';
-export declare function parseGroupBy(ctx: ParseContext, orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];
+export declare function parseGroupBy(orderBy: ReferenceExpressionOrList<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(ctx, orderBy) {
-    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(ctx, orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
+function parseGroupBy(orderBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
 }
 exports.parseGroupBy = parseGroupBy;

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

@@ -1,5 +1,4 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { ParseContext } from './parse-context.js';
 import { ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
@@ -9,4 +8,4 @@ export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
+export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

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

@@ -8,15 +8,15 @@ 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");
-function parseInsertObjectOrList(ctx, args) {
-    return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
+function parseInsertObjectOrList(args) {
+    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
 exports.parseInsertObjectOrList = parseInsertObjectOrList;
-function parseInsertColumnsAndValues(ctx, rows) {
+function parseInsertColumnsAndValues(rows) {
     const columns = parseColumnNamesAndIndexes(rows);
     return [
         (0, object_utils_js_1.freeze)([...columns.keys()].map(column_node_js_1.ColumnNode.create)),
-        values_node_js_1.ValuesNode.create(rows.map((row) => parseRowValues(ctx, row, columns))),
+        values_node_js_1.ValuesNode.create(rows.map((row) => parseRowValues(row, columns))),
     ];
 }
 function parseColumnNamesAndIndexes(rows) {
@@ -31,7 +31,7 @@ function parseColumnNamesAndIndexes(rows) {
     }
     return columns;
 }
-function parseRowValues(ctx, row, columns) {
+function parseRowValues(row, columns) {
     const rowColumns = Object.keys(row);
     const rowValues = new Array(columns.size).fill(null);
     for (const col of rowColumns) {
@@ -42,7 +42,7 @@ function parseRowValues(ctx, row, columns) {
         }
     }
     if (rowValues.some(complex_expression_parser_js_1.isComplexExpression)) {
-        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(ctx, it)));
+        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(it)));
     }
     return primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues);
 }

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

@@ -2,10 +2,9 @@ import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
 import { TableExpressionDatabase, TableExpressionTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-import { ParseContext } from './parse-context.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<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>) => JoinBuilder<any, any>;
 declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
 declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
+export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
 export {};

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

@@ -4,22 +4,23 @@ 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");
-function parseJoin(ctx, joinType, args) {
+const parse_utils_js_1 = require("./parse-utils.js");
+function parseJoin(joinType, args) {
     if (args.length === 3) {
-        return parseSingleOnJoin(ctx, joinType, args[0], args[1], args[2]);
+        return parseSingleOnJoin(joinType, args[0], args[1], args[2]);
     }
     else if (args.length === 2) {
-        return parseCallbackJoin(ctx, joinType, args[0], args[1]);
+        return parseCallbackJoin(joinType, args[0], args[1]);
     }
     else {
         throw new Error('not implemented');
     }
 }
 exports.parseJoin = parseJoin;
-function parseCallbackJoin(ctx, joinType, from, callback) {
-    const joinBuilder = callback(ctx.createJoinBuilder(joinType, from));
+function parseCallbackJoin(joinType, from, callback) {
+    const joinBuilder = callback((0, parse_utils_js_1.createJoinBuilder)(joinType, from));
     return joinBuilder.toOperationNode();
 }
-function parseSingleOnJoin(ctx, joinType, from, lhsColumn, rhsColumn) {
-    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(ctx, from), (0, filter_parser_js_1.parseReferenceFilter)(ctx, lhsColumn, '=', rhsColumn));
+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));
 }

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

@@ -1,8 +1,7 @@
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
-import { ParseContext } from './parse-context.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 function parseOrderBy(ctx: ParseContext, orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;
+export declare function parseOrderBy(orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

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

@@ -4,12 +4,12 @@ exports.parseOrderBy = void 0;
 const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
-function parseOrderBy(ctx, orderBy, direction) {
-    return order_by_item_node_js_1.OrderByItemNode.create(parseOrderByExpression(ctx, orderBy), parseOrderByDirectionExpression(direction));
+function parseOrderBy(orderBy, direction) {
+    return order_by_item_node_js_1.OrderByItemNode.create(parseOrderByExpression(orderBy), parseOrderByDirectionExpression(direction));
 }
 exports.parseOrderBy = parseOrderBy;
-function parseOrderByExpression(ctx, expr) {
-    return (0, reference_parser_js_1.parseReferenceExpression)(ctx, expr);
+function parseOrderByExpression(expr) {
+    return (0, reference_parser_js_1.parseReferenceExpression)(expr);
 }
 function parseOrderByDirectionExpression(expr) {
     if (!expr) {

package/dist/cjs/parser/parse-utils.d.ts

@@ -0,0 +1,10 @@
+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 { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { QueryCreator } from '../query-creator.js';
+import { TableExpression } from './table-parser.js';
+export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, 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>;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJoinBuilder = exports.createQueryCreator = exports.createExpressionBuilder = exports.createSelectQueryBuilder = void 0;
+const join_node_js_1 = require("../operation-node/join-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 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");
+const query_id_js_1 = require("../util/query-id.js");
+const table_parser_js_1 = require("./table-parser.js");
+function createSelectQueryBuilder() {
+    return new select_query_builder_js_1.SelectQueryBuilder({
+        queryId: (0, query_id_js_1.createQueryId)(),
+        executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
+        queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)([])),
+    });
+}
+exports.createSelectQueryBuilder = createSelectQueryBuilder;
+function createExpressionBuilder() {
+    return new expression_builder_js_1.ExpressionBuilder({
+        executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
+    });
+}
+exports.createExpressionBuilder = createExpressionBuilder;
+function createQueryCreator() {
+    return new query_creator_js_1.QueryCreator({
+        executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
+    });
+}
+exports.createQueryCreator = createQueryCreator;
+function createJoinBuilder(joinType, table) {
+    return new join_builder_js_1.JoinBuilder({
+        joinNode: join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(table)),
+    });
+}
+exports.createJoinBuilder = createJoinBuilder;

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

@@ -5,7 +5,6 @@ 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 { ParseContext } from './parse-context.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
@@ -14,8 +13,8 @@ export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = Referen
 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(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
-export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
+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 function parseColumnName(column: AnyColumn<any, any>): ColumnNode;

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

@@ -8,23 +8,23 @@ 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");
-function parseReferenceExpressionOrList(ctx, arg) {
+function parseReferenceExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
-        return arg.map((it) => parseReferenceExpression(ctx, it));
+        return arg.map((it) => parseReferenceExpression(it));
     }
     else {
-        return [parseReferenceExpression(ctx, arg)];
+        return [parseReferenceExpression(arg)];
     }
 }
 exports.parseReferenceExpressionOrList = parseReferenceExpressionOrList;
-function parseReferenceExpression(ctx, exp) {
+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();
     }
-    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
+    return (0, complex_expression_parser_js_1.parseComplexExpression)(exp);
 }
 exports.parseReferenceExpression = parseReferenceExpression;
 function parseStringReference(ref) {

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

@@ -3,7 +3,6 @@ import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select
 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 { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-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>;
@@ -29,6 +28,6 @@ declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
         [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
     }[TB];
 }>;
-export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
+export declare function parseSelectExpressionOrList(selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

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

@@ -6,16 +6,16 @@ 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");
-function parseSelectExpressionOrList(ctx, selection) {
+function parseSelectExpressionOrList(selection) {
     if ((0, object_utils_js_1.isReadonlyArray)(selection)) {
-        return selection.map((it) => parseSelectExpression(ctx, it));
+        return selection.map((it) => parseSelectExpression(it));
     }
     else {
-        return [parseSelectExpression(ctx, selection)];
+        return [parseSelectExpression(selection)];
     }
 }
 exports.parseSelectExpressionOrList = parseSelectExpressionOrList;
-function parseSelectExpression(ctx, selection) {
+function parseSelectExpression(selection) {
     if ((0, object_utils_js_1.isString)(selection)) {
         return selection_node_js_1.SelectionNode.create((0, reference_parser_js_1.parseAliasedStringReference)(selection));
     }
@@ -23,7 +23,7 @@ function parseSelectExpression(ctx, 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)(ctx, selection));
+        return selection_node_js_1.SelectionNode.create((0, complex_expression_parser_js_1.parseAliasedComplexExpression)(selection));
     }
 }
 function parseSelectAll(table) {

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

@@ -3,7 +3,6 @@ import { TableNode } from '../operation-node/table-node.js';
 import { AnyAliasedRawBuilder, Nullable } from '../util/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
@@ -25,8 +24,8 @@ export declare type TableExpressionTables<DB, TB extends keyof DB, TE> = TB | Ex
 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 AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
-export declare function parseTableExpressionOrList(ctx: ParseContext, table: TableExpressionOrList<any, any>): TableExpressionNode[];
-export declare function parseTableExpression(ctx: ParseContext, table: TableExpression<any, any>): TableExpressionNode;
+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 parseTable(from: string): TableNode;
 export {};

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

@@ -5,21 +5,21 @@ 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");
-function parseTableExpressionOrList(ctx, table) {
+function parseTableExpressionOrList(table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
-        return table.map((it) => parseTableExpression(ctx, it));
+        return table.map((it) => parseTableExpression(it));
     }
     else {
-        return [parseTableExpression(ctx, table)];
+        return [parseTableExpression(table)];
     }
 }
 exports.parseTableExpressionOrList = parseTableExpressionOrList;
-function parseTableExpression(ctx, table) {
+function parseTableExpression(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return parseAliasedTable(table);
     }
     else {
-        return (0, complex_expression_parser_js_1.parseAliasedComplexExpression)(ctx, table);
+        return (0, complex_expression_parser_js_1.parseAliasedComplexExpression)(table);
     }
 }
 exports.parseTableExpression = parseTableExpression;

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

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

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

@@ -4,11 +4,11 @@ exports.parseUpdateObject = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const column_update_node_js_1 = require("../operation-node/column-update-node.js");
 const value_parser_js_1 = require("./value-parser.js");
-function parseUpdateObject(ctx, row) {
+function parseUpdateObject(row) {
     return Object.entries(row)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {
-        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(ctx, value));
+        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(value));
     });
 }
 exports.parseUpdateObject = parseUpdateObject;

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

@@ -1,10 +1,9 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { ParseContext } from './parse-context.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>;
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<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(ctx: ParseContext, arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode;

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

@@ -6,25 +6,25 @@ 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");
-function parseValueExpressionOrList(ctx, arg) {
+function parseValueExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
-        return parseValueExpressionList(ctx, arg);
+        return parseValueExpressionList(arg);
     }
     else {
-        return parseValueExpression(ctx, arg);
+        return parseValueExpression(arg);
     }
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
-function parseValueExpression(ctx, exp) {
+function parseValueExpression(exp) {
     if ((0, complex_expression_parser_js_1.isComplexExpression)(exp)) {
-        return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
+        return (0, complex_expression_parser_js_1.parseComplexExpression)(exp);
     }
     return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
-function parseValueExpressionList(ctx, arg) {
+function parseValueExpressionList(arg) {
     if (arg.some(complex_expression_parser_js_1.isComplexExpression)) {
-        return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
+        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

@@ -5,7 +5,6 @@ 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 { ParseContext } from './parse-context.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>>>;
@@ -37,5 +36,5 @@ declare type ExtractRowFromCommonTableExpressionName<CN extends string> = CN ext
  * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
  */
 declare type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
-export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
+export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
 export {};

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

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCommonTableExpression = void 0;
 const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
 const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
-function parseCommonTableExpression(ctx, name, expression) {
-    const builder = expression(ctx.createQueryCreator());
+const parse_utils_js_1 = require("./parse-utils.js");
+function parseCommonTableExpression(name, expression) {
+    const builder = expression((0, parse_utils_js_1.createQueryCreator)());
     return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
 }
 exports.parseCommonTableExpression = parseCommonTableExpression;