kysely 0.16.9 → 0.17.1

package/dist/esm/kysely.js

@@ -9,10 +9,8 @@ import { RuntimeDriver } from './driver/runtime-driver.js';
 import { SingleConnectionProvider } from './driver/single-connection-provider.js';
 import { TRANSACTION_ISOLATION_LEVELS, } from './driver/driver.js';
 import { preventAwait } from './util/prevent-await.js';
-import { DefaultParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
 import { Log } from './util/log.js';
-import { PRIVATE_ADAPTER } from './util/private-symbols.js';
 /**
  * The main Kysely class.
  *
@@ -62,7 +60,7 @@ export class Kysely extends QueryCreator {
         let superProps;
         let props;
         if (isKyselyProps(args)) {
-            superProps = { executor: args.executor, parseContext: args.parseContext };
+            superProps = { executor: args.executor };
             props = { ...args };
         }
         else {
@@ -71,17 +69,15 @@ export class Kysely extends QueryCreator {
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
             const log = new Log(args.log ?? []);
-            const parseContext = new DefaultParseContext(adapter);
             const runtimeDriver = new RuntimeDriver(driver, log);
             const connectionProvider = new DefaultConnectionProvider(runtimeDriver);
-            const executor = new DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
-            superProps = { executor, parseContext };
+            const executor = new DefaultQueryExecutor(compiler, adapter, connectionProvider, args.plugins ?? []);
+            superProps = { executor };
             props = {
                 config: args,
                 executor,
                 dialect,
                 driver: runtimeDriver,
-                parseContext,
             };
         }
         super(superProps);
@@ -137,7 +133,7 @@ export class Kysely extends QueryCreator {
      * ```
      */
     get fn() {
-        return new FunctionBuilder({ executor: this.#props.executor });
+        return new FunctionBuilder();
     }
     /**
      * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
@@ -283,8 +279,8 @@ export class Kysely extends QueryCreator {
      * @internal
      * @private
      */
-    get [PRIVATE_ADAPTER]() {
-        return this.#props.parseContext.adapter;
+    getExecutor() {
+        return this.#props.executor;
     }
 }
 export class Transaction extends Kysely {
@@ -329,8 +325,7 @@ export function isKyselyProps(obj) {
         isObject(obj.config) &&
         isObject(obj.driver) &&
         isObject(obj.executor) &&
-        isObject(obj.dialect) &&
-        isObject(obj.parseContext));
+        isObject(obj.dialect));
 }
 export class ConnectionBuilder {
     #props;
@@ -338,18 +333,14 @@ export class ConnectionBuilder {
         this.#props = freeze(props);
     }
     async execute(callback) {
-        const connection = await this.#props.driver.acquireConnection();
-        const connectionProvider = new SingleConnectionProvider(connection);
-        const transaction = new Kysely({
-            ...this.#props,
-            executor: this.#props.executor.withConnectionProvider(connectionProvider),
+        return this.#props.executor.provideConnection(async (connection) => {
+            const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+            const db = new Kysely({
+                ...this.#props,
+                executor,
+            });
+            return await callback(db);
         });
-        try {
-            return await callback(transaction);
-        }
-        finally {
-            await this.#props.driver.releaseConnection(connection);
-        }
     }
 }
 preventAwait(ConnectionBuilder, "don't await ConnectionBuilder instances directly. To execute the query you need to call the `execute` method");
@@ -368,25 +359,23 @@ export class TransactionBuilder {
         const { isolationLevel, ...kyselyProps } = this.#props;
         const settings = { isolationLevel };
         validateTransactionSettings(settings);
-        const connection = await this.#props.driver.acquireConnection();
-        const connectionProvider = new SingleConnectionProvider(connection);
-        const transaction = new Transaction({
-            ...kyselyProps,
-            executor: this.#props.executor.withConnectionProvider(connectionProvider),
+        return this.#props.executor.provideConnection(async (connection) => {
+            const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+            const transaction = new Transaction({
+                ...kyselyProps,
+                executor,
+            });
+            try {
+                await this.#props.driver.beginTransaction(connection, settings);
+                const result = await callback(transaction);
+                await this.#props.driver.commitTransaction(connection);
+                return result;
+            }
+            catch (error) {
+                await this.#props.driver.rollbackTransaction(connection);
+                throw error;
+            }
         });
-        try {
-            await this.#props.driver.beginTransaction(connection, settings);
-            const result = await callback(transaction);
-            await this.#props.driver.commitTransaction(connection);
-            return result;
-        }
-        catch (error) {
-            await this.#props.driver.rollbackTransaction(connection);
-            throw error;
-        }
-        finally {
-            await this.#props.driver.releaseConnection(connection);
-        }
     }
 }
 preventAwait(TransactionBuilder, "don't await TransactionBuilder instances directly. To execute the transaction you need to call the `execute` method");

package/dist/esm/migration/migrator.js

@@ -1,6 +1,5 @@
 /// <reference types="./migrator.d.ts" />
 import { freeze, getLast } from '../util/object-utils.js';
-import { PRIVATE_ADAPTER } from '../util/private-symbols.js';
 export const MIGRATION_TABLE = 'kysely_migration';
 export const MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 export const MIGRATION_LOCK_ID = 'migration_lock';
@@ -260,9 +259,10 @@ export class Migrator {
         return !!lockRow;
     }
     async #runMigrations(getTargetMigrationIndex) {
+        const adapter = this.#props.db.getExecutor().adapter;
         const run = async (db) => {
             try {
-                await this.#props.db[PRIVATE_ADAPTER].acquireMigrationLock(db);
+                await adapter.acquireMigrationLock(db);
                 const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
@@ -280,10 +280,10 @@ export class Migrator {
                 return { results: [] };
             }
             finally {
-                await this.#props.db[PRIVATE_ADAPTER].releaseMigrationLock(db);
+                await adapter.releaseMigrationLock(db);
             }
         };
-        if (this.#props.db[PRIVATE_ADAPTER].supportsTransactionalDdl) {
+        if (adapter.supportsTransactionalDdl) {
             return this.#props.db.transaction().execute(run);
         }
         else {

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

@@ -5,6 +5,9 @@ import { TableExpressionNode } from './operation-node-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { LimitNode } from './limit-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -12,6 +15,8 @@ export interface DeleteQueryNode extends OperationNode {
     readonly where?: WhereNode;
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
+    readonly orderBy?: OrderByNode;
+    readonly limit?: LimitNode;
 }
 /**
  * @internal
@@ -19,4 +24,6 @@ export interface DeleteQueryNode extends OperationNode {
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItem: TableExpressionNode, withNode?: WithNode | undefined): DeleteQueryNode;
+    cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
+    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
 }>;

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

@@ -1,6 +1,7 @@
 /// <reference types="./delete-query-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { FromNode } from './from-node.js';
+import { OrderByNode } from './order-by-node.js';
 /**
  * @internal
  */
@@ -15,4 +16,18 @@ export const DeleteQueryNode = freeze({
             ...(withNode && { with: withNode }),
         });
     },
+    cloneWithOrderByItem(deleteNode, item) {
+        return freeze({
+            ...deleteNode,
+            orderBy: deleteNode.orderBy
+                ? OrderByNode.cloneWithItem(deleteNode.orderBy, item)
+                : OrderByNode.create(item),
+        });
+    },
+    cloneWithLimit(deleteNode, limit) {
+        return freeze({
+            ...deleteNode,
+            limit,
+        });
+    },
 });

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

@@ -218,7 +218,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'RawNode',
             sqlFragments: freeze([...node.sqlFragments]),
-            params: this.transformNodeList(node.params),
+            parameters: this.transformNodeList(node.parameters),
         };
     }
     transformWhere(node) {

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

@@ -2,13 +2,15 @@ import { OperationNode } from './operation-node.js';
 export interface RawNode extends OperationNode {
     readonly kind: 'RawNode';
     readonly sqlFragments: ReadonlyArray<string>;
-    readonly params: ReadonlyArray<OperationNode>;
+    readonly parameters: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const RawNode: Readonly<{
     is(node: OperationNode): node is RawNode;
-    create(sqlFragments: ReadonlyArray<string>, params: ReadonlyArray<OperationNode>): RawNode;
+    create(sqlFragments: ReadonlyArray<string>, parameters: ReadonlyArray<OperationNode>): RawNode;
     createWithSql(sql: string): RawNode;
+    createWithChild(child: OperationNode): RawNode;
+    createWithChildren(children: ReadonlyArray<OperationNode>): RawNode;
 }>;

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

@@ -7,14 +7,20 @@ export const RawNode = freeze({
     is(node) {
         return node.kind === 'RawNode';
     },
-    create(sqlFragments, params) {
+    create(sqlFragments, parameters) {
         return freeze({
             kind: 'RawNode',
             sqlFragments: freeze(sqlFragments),
-            params: freeze(params),
+            parameters: freeze(parameters),
         });
     },
     createWithSql(sql) {
         return RawNode.create([sql], []);
     },
+    createWithChild(child) {
+        return RawNode.create(['', ''], [child]);
+    },
+    createWithChildren(children) {
+        return RawNode.create(new Array(children.length + 1).fill(''), children);
+    },
 });

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

@@ -1,10 +1,10 @@
+import { RawBuilder } from '../index-nodeless.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, AnyRawBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-import { ParseContext } from './parse-context.js';
-export declare type ComplexExpression<DB, TB extends keyof DB> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
+export declare type ComplexExpression<DB, TB extends keyof DB, V = any> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | RawBuilder<V> | RawBuilderFactory<DB, TB>;
 export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
-export declare function parseComplexExpression(ctx: ParseContext, exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
-export declare function parseAliasedComplexExpression(ctx: ParseContext, exp: AliasedComplexExpression<any, any>): AliasNode;
+export declare function parseComplexExpression(exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
+export declare function parseAliasedComplexExpression(exp: AliasedComplexExpression<any, any>): AliasNode;
 export declare function isComplexExpression(obj: unknown): obj is ComplexExpression<any, any>;

package/dist/esm/parser/complex-expression-parser.js

@@ -1,21 +1,22 @@
 /// <reference types="./complex-expression-parser.d.ts" />
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { isFunction } from '../util/object-utils.js';
-export function parseComplexExpression(ctx, exp) {
+import { createExpressionBuilder } from './parse-utils.js';
+export function parseComplexExpression(exp) {
     if (isOperationNodeSource(exp)) {
         return exp.toOperationNode();
     }
     else if (isFunction(exp)) {
-        return exp(ctx.createExpressionBuilder()).toOperationNode();
+        return exp(createExpressionBuilder()).toOperationNode();
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
-export function parseAliasedComplexExpression(ctx, exp) {
+export function parseAliasedComplexExpression(exp) {
     if (isOperationNodeSource(exp)) {
         return exp.toOperationNode();
     }
     else if (isFunction(exp)) {
-        return exp(ctx.createExpressionBuilder()).toOperationNode();
+        return exp(createExpressionBuilder()).toOperationNode();
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }

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

@@ -4,21 +4,21 @@ import { Operator } from '../operation-node/operator-node.js';
 import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
 import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
 import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ParseContext } from './parse-context.js';
 import { WhereInterface } from '../query-builder/where-interface.js';
 import { HavingInterface } from '../query-builder/having-interface.js';
+import { ComplexExpression } from './complex-expression-parser.js';
 export declare type FilterValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 export declare type FilterValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
-export declare type ExistsExpression<DB, TB extends keyof DB> = ValueExpression<DB, TB, never>;
+export declare type ExistsExpression<DB, TB extends keyof DB> = ComplexExpression<DB, TB, any>;
 export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
 export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
 export declare type FilterOperator = Operator | AnyRawBuilder;
 declare type FilterType = 'where' | 'having' | 'on';
-export declare function parseWhereFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
-export declare function parseHavingFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
-export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
-export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
-export declare function parseExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseNotExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseFilter(ctx: ParseContext, type: FilterType, args: any[]): FilterExpressionNode;
+export declare function parseWhereFilter(args: any[]): FilterExpressionNode;
+export declare function parseHavingFilter(args: any[]): FilterExpressionNode;
+export declare function parseOnFilter(args: any[]): FilterExpressionNode;
+export declare function parseReferenceFilter(lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
+export declare function parseExistFilter(arg: ExistsExpression<any, any>): FilterNode;
+export declare function parseNotExistFilter(arg: ExistsExpression<any, any>): FilterNode;
+export declare function parseFilter(type: FilterType, args: any[]): FilterExpressionNode;
 export {};

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

@@ -8,41 +8,42 @@ 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';
-export function parseWhereFilter(ctx, args) {
-    return parseFilter(ctx, 'where', args);
+import { createJoinBuilder, createSelectQueryBuilder } from './parse-utils.js';
+export function parseWhereFilter(args) {
+    return parseFilter('where', args);
 }
-export function parseHavingFilter(ctx, args) {
-    return parseFilter(ctx, 'having', args);
+export function parseHavingFilter(args) {
+    return parseFilter('having', args);
 }
-export function parseOnFilter(ctx, args) {
-    return parseFilter(ctx, 'on', args);
+export function parseOnFilter(args) {
+    return parseFilter('on', args);
 }
-export function parseReferenceFilter(ctx, lhs, op, rhs) {
-    return FilterNode.create(parseReferenceExpression(ctx, lhs), parseFilterOperator(op), parseReferenceExpression(ctx, rhs));
+export function parseReferenceFilter(lhs, op, rhs) {
+    return FilterNode.create(parseReferenceExpression(lhs), parseFilterOperator(op), parseReferenceExpression(rhs));
 }
-export function parseExistFilter(ctx, arg) {
-    return parseExistExpression(ctx, 'exists', arg);
+export function parseExistFilter(arg) {
+    return parseExistExpression('exists', arg);
 }
-export function parseNotExistFilter(ctx, arg) {
-    return parseExistExpression(ctx, 'not exists', arg);
+export function parseNotExistFilter(arg) {
+    return parseExistExpression('not exists', arg);
 }
-export function parseFilter(ctx, type, args) {
+export 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);
 }
-function parseThreeArgFilter(ctx, left, op, right) {
+function parseThreeArgFilter(left, op, right) {
     if ((op === 'is' || op === 'is not') && (isNull(right) || isBoolean(right))) {
-        return parseIsFilter(ctx, left, op, right);
+        return parseIsFilter(left, op, right);
     }
-    return FilterNode.create(parseReferenceExpression(ctx, left), parseFilterOperator(op), parseValueExpressionOrList(ctx, right));
+    return FilterNode.create(parseReferenceExpression(left), parseFilterOperator(op), parseValueExpressionOrList(right));
 }
-function parseIsFilter(ctx, left, op, right) {
-    return FilterNode.create(parseReferenceExpression(ctx, left), parseFilterOperator(op), ValueNode.createImmediate(right));
+function parseIsFilter(left, op, right) {
+    return FilterNode.create(parseReferenceExpression(left), parseFilterOperator(op), ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
     if (isString(op) && OPERATORS.includes(op)) {
@@ -53,12 +54,12 @@ function parseFilterOperator(op) {
     }
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
-function parseExistExpression(ctx, type, arg) {
-    return FilterNode.create(undefined, OperatorNode.create(type), parseValueExpressionOrList(ctx, arg));
+function parseExistExpression(type, arg) {
+    return FilterNode.create(undefined, OperatorNode.create(type), parseValueExpressionOrList(arg));
 }
-function parseOneArgFilter(ctx, type, arg) {
+function parseOneArgFilter(type, arg) {
     if (isFunction(arg)) {
-        return GROUP_PARSERS[type](ctx, arg);
+        return GROUP_PARSERS[type](arg);
     }
     else if (isOperationNodeSource(arg)) {
         const node = arg.toOperationNode();
@@ -72,24 +73,24 @@ function createFilterError(type, args) {
     return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
 }
 const GROUP_PARSERS = freeze({
-    where(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder());
+    where(callback) {
+        const query = callback(createSelectQueryBuilder());
         const queryNode = query.toOperationNode();
         if (!queryNode.where) {
             throw new Error('no `where` methods called insided a group callback');
         }
         return ParensNode.create(queryNode.where.where);
     },
-    having(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder());
+    having(callback) {
+        const query = callback(createSelectQueryBuilder());
         const queryNode = query.toOperationNode();
         if (!queryNode.having) {
             throw new Error('no `having` methods called insided a group callback');
         }
         return ParensNode.create(queryNode.having.having);
     },
-    on(ctx, callback) {
-        const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
+    on(callback) {
+        const joinBuilder = callback(createJoinBuilder('InnerJoin', 'table'));
         const joinNode = joinBuilder.toOperationNode();
         if (!joinNode.on) {
             throw new Error('no `on` methods called insided a group callback');

package/dist/esm/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/esm/parser/group-by-parser.js

@@ -1,6 +1,6 @@
 /// <reference types="./group-by-parser.d.ts" />
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { parseReferenceExpressionOrList, } from './reference-parser.js';
-export function parseGroupBy(ctx, orderBy) {
-    return parseReferenceExpressionOrList(ctx, orderBy).map(GroupByItemNode.create);
+export function parseGroupBy(orderBy) {
+    return parseReferenceExpressionOrList(orderBy).map(GroupByItemNode.create);
 }

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

@@ -6,14 +6,14 @@ import { freeze } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { isComplexExpression } from './complex-expression-parser.js';
-export function parseInsertObjectOrList(ctx, args) {
-    return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
+export function parseInsertObjectOrList(args) {
+    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
-function parseInsertColumnsAndValues(ctx, rows) {
+function parseInsertColumnsAndValues(rows) {
     const columns = parseColumnNamesAndIndexes(rows);
     return [
         freeze([...columns.keys()].map(ColumnNode.create)),
-        ValuesNode.create(rows.map((row) => parseRowValues(ctx, row, columns))),
+        ValuesNode.create(rows.map((row) => parseRowValues(row, columns))),
     ];
 }
 function parseColumnNamesAndIndexes(rows) {
@@ -28,7 +28,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) {
@@ -39,7 +39,7 @@ function parseRowValues(ctx, row, columns) {
         }
     }
     if (rowValues.some(isComplexExpression)) {
-        return ValueListNode.create(rowValues.map((it) => parseValueExpression(ctx, it)));
+        return ValueListNode.create(rowValues.map((it) => parseValueExpression(it)));
     }
     return PrimitiveValueListNode.create(rowValues);
 }

package/dist/esm/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/esm/parser/join-parser.js

@@ -2,21 +2,22 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { parseTableExpression, } from './table-parser.js';
 import { parseReferenceFilter } from './filter-parser.js';
-export function parseJoin(ctx, joinType, args) {
+import { createJoinBuilder } from './parse-utils.js';
+export 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');
     }
 }
-function parseCallbackJoin(ctx, joinType, from, callback) {
-    const joinBuilder = callback(ctx.createJoinBuilder(joinType, from));
+function parseCallbackJoin(joinType, from, callback) {
+    const joinBuilder = callback(createJoinBuilder(joinType, from));
     return joinBuilder.toOperationNode();
 }
-function parseSingleOnJoin(ctx, joinType, from, lhsColumn, rhsColumn) {
-    return JoinNode.createWithOn(joinType, parseTableExpression(ctx, from), parseReferenceFilter(ctx, lhsColumn, '=', rhsColumn));
+function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
+    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferenceFilter(lhsColumn, '=', rhsColumn));
 }

package/dist/esm/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/esm/parser/order-by-parser.js

@@ -2,11 +2,11 @@
 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 parseOrderBy(ctx, orderBy, direction) {
-    return OrderByItemNode.create(parseOrderByExpression(ctx, orderBy), parseOrderByDirectionExpression(direction));
+export function parseOrderBy(orderBy, direction) {
+    return OrderByItemNode.create(parseOrderByExpression(orderBy), parseOrderByDirectionExpression(direction));
 }
-function parseOrderByExpression(ctx, expr) {
-    return parseReferenceExpression(ctx, expr);
+function parseOrderByExpression(expr) {
+    return parseReferenceExpression(expr);
 }
 function parseOrderByDirectionExpression(expr) {
     if (!expr) {

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