kysely 0.7.2 → 0.7.6

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

@@ -8,13 +8,12 @@ import { parseReferenceExpression, } from './reference-parser.js';
 import { parseValueExpressionOrList, } from './value-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { parseTableExpression } from './table-parser.js';
 export function parseWhereFilter(ctx, args) {
     if (args.length === 3) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && isFunction(args[0])) {
-        return parseWhereGrouper(ctx, args[0]);
+        return parseWhereGroup(ctx, args[0]);
     }
     else {
         throw new Error(`invalid arguments passed to a where method ${JSON.stringify(args)}`);
@@ -25,7 +24,7 @@ export function parseHavingFilter(ctx, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && isFunction(args[0])) {
-        return parseHavingGrouper(ctx, args[0]);
+        return parseHavingGroup(ctx, args[0]);
     }
     else {
         throw new Error(`invalid arguments passed to a having method ${JSON.stringify(args)}`);
@@ -36,7 +35,7 @@ export function parseOnFilter(ctx, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && isFunction(args[0])) {
-        return parseOnGrouper(ctx, args[0]);
+        return parseOnGroup(ctx, args[0]);
     }
     else {
         throw new Error(`invalid arguments passed to an on method ${JSON.stringify(args)}`);
@@ -45,20 +44,11 @@ export function parseOnFilter(ctx, args) {
 export function parseReferenceFilter(ctx, lhs, op, rhs) {
     return FilterNode.create(parseReferenceExpression(ctx, lhs), parseFilterOperator(op), parseReferenceExpression(ctx, rhs));
 }
-export function parseExistExpression(ctx, arg) {
-    return doParseExistExpression(ctx, 'exists', arg);
+export function parseExistFilter(ctx, arg) {
+    return parseExistExpression(ctx, 'exists', arg);
 }
-export function parseNotExistExpression(ctx, arg) {
-    return doParseExistExpression(ctx, 'not exists', arg);
-}
-function doParseExistExpression(ctx, type, arg) {
-    const node = isFunction(arg)
-        ? arg(ctx.createSubQueryBuilder()).toOperationNode()
-        : arg.toOperationNode();
-    if (!SelectQueryNode.is(node) && !RawNode.is(node)) {
-        throw new Error('invalid where exists arg');
-    }
-    return FilterNode.create(undefined, OperatorNode.create(type), node);
+export function parseNotExistFilter(ctx, arg) {
+    return parseExistExpression(ctx, 'not exists', arg);
 }
 function parseThreeArgFilter(ctx, left, op, right) {
     if ((op === 'is' || op === 'is not') && (isNull(right) || isBoolean(right))) {
@@ -70,38 +60,46 @@ function parseIsFilter(ctx, left, op, right) {
     return FilterNode.create(parseReferenceExpression(ctx, left), parseFilterOperator(op), ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
-    if (isOperationNodeSource(op)) {
-        return op.toOperationNode();
-    }
-    else if (isString(op)) {
-        const opString = op.trim().toLowerCase();
-        if (OPERATORS.some((it) => it === opString)) {
-            return OperatorNode.create(opString);
+    if (isString(op)) {
+        if (OPERATORS.includes(op)) {
+            return OperatorNode.create(op);
         }
     }
+    else if (isOperationNodeSource(op)) {
+        return op.toOperationNode();
+    }
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
-function parseWhereGrouper(ctx, grouper) {
-    const query = grouper(ctx.createEmptySelectQuery());
+function parseWhereGroup(ctx, callback) {
+    const query = callback(ctx.createSelectQueryBuilder([]));
     const queryNode = query.toOperationNode();
     if (!queryNode.where) {
-        throw new Error('no where methods called insided a grouper');
+        throw new Error('no `where*` methods called insided a group callback');
     }
     return ParensNode.create(queryNode.where.where);
 }
-function parseHavingGrouper(ctx, grouper) {
-    const query = grouper(ctx.createEmptySelectQuery());
+function parseHavingGroup(ctx, callback) {
+    const query = callback(ctx.createSelectQueryBuilder([]));
     const queryNode = query.toOperationNode();
     if (!queryNode.having) {
-        throw new Error('no having methods called insided a grouper');
+        throw new Error('no `having*` methods called insided a group callback');
     }
     return ParensNode.create(queryNode.having.having);
 }
-function parseOnGrouper(ctx, grouper) {
-    const joinBuilder = grouper(ctx.createJoinBuilder('InnerJoin', parseTableExpression(ctx, 'table')));
+function parseOnGroup(ctx, callback) {
+    const joinBuilder = callback(ctx.createJoinBuilder('InnerJoin', 'table'));
     const joinNode = joinBuilder.toOperationNode();
     if (!joinNode.on) {
-        throw new Error('no `on` methods called insided a grouper where');
+        throw new Error('no `on*` methods called insided a group callback');
     }
     return ParensNode.create(joinNode.on);
 }
+function parseExistExpression(ctx, type, arg) {
+    const node = isFunction(arg)
+        ? arg(ctx.createExpressionBuilder()).toOperationNode()
+        : arg.toOperationNode();
+    if (!SelectQueryNode.is(node) && !RawNode.is(node)) {
+        throw new Error('invalid where exists arg');
+    }
+    return FilterNode.create(undefined, OperatorNode.create(type), node);
+}

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

@@ -5,4 +5,4 @@ import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';
 export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
 export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
-export declare function parseJoinArgs(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
+export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;

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

@@ -1,23 +1,21 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { parseTableExpression, } from './table-parser.js';
 import { parseReferenceFilter } from './filter-parser.js';
-export function parseJoinArgs(ctx, joinType, args) {
-    if (args.length === 2) {
-        return parseCallbackJoin(ctx, joinType, args[0], args[1]);
-    }
-    else if (args.length === 3) {
+export function parseJoin(ctx, joinType, args) {
+    if (args.length === 3) {
         return parseSingleOnJoin(ctx, joinType, args[0], args[1], args[2]);
     }
+    else if (args.length === 2) {
+        return parseCallbackJoin(ctx, joinType, args[0], args[1]);
+    }
     else {
         throw new Error('not implemented');
     }
 }
 function parseCallbackJoin(ctx, joinType, from, callback) {
-    const tableNode = parseTableExpression(ctx, from);
-    const joinBuilder = callback(ctx.createJoinBuilder(joinType, tableNode));
+    const joinBuilder = callback(ctx.createJoinBuilder(joinType, from));
     return joinBuilder.toOperationNode();
 }
 function parseSingleOnJoin(ctx, joinType, from, lhsColumn, rhsColumn) {
-    const tableNode = parseTableExpression(ctx, from);
-    return JoinNode.cloneWithOn(JoinNode.create(joinType, tableNode), 'And', parseReferenceFilter(ctx, lhsColumn, '=', rhsColumn));
+    return JoinNode.createWithOn(joinType, parseTableExpression(ctx, from), parseReferenceFilter(ctx, lhsColumn, '=', rhsColumn));
 }

package/dist/esm/parser/parse-context.d.ts

@@ -1,14 +1,41 @@
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
 import { JoinType } from '../operation-node/join-node.js';
-import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
-import { SubQueryBuilder } from '../query-builder/sub-query-builder.js';
+import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { QueryCreator } from '../query-creator.js';
+import { TableExpression } from './table-parser.js';
+/**
+ * This interface exposes everything the parsers need to be able to parse
+ * method calls into {@link OperationNode} trees.
+ */
 export interface ParseContext {
-    createEmptySelectQuery(): QueryBuilder<any, any>;
-    createSubQueryBuilder(): SubQueryBuilder<any, any>;
+    readonly adapter: DialectAdapter;
+    /**
+     * Creates a select query builder with a {@link NoopQueryExecutor}.
+     */
+    createSelectQueryBuilder(tables: ReadonlyArray<TableExpression<any, any>>): QueryBuilder<any, any>;
+    /**
+     * Creates an instance of a join builder.
+     */
+    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+    /**
+     * Creates an expression builder for building stuff like subqueries.
+     * {@link NoopQueryExecutor} is used as the executor and the queries
+     * built using the returned builder can never be executed.
+     */
+    createExpressionBuilder(): ExpressionBuilder<any, any>;
+    /**
+     * Creates a query creator with a {@link NoopQueryExecutor}.
+     */
+    createQueryCreator(): QueryCreator<any>;
+}
+export declare class DefaultParseContext implements ParseContext {
+    #private;
+    constructor(adapter: DialectAdapter);
+    get adapter(): DialectAdapter;
+    createSelectQueryBuilder(tables: ReadonlyArray<TableExpression<any, any>>): QueryBuilder<any, any>;
+    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+    createExpressionBuilder(): ExpressionBuilder<any, any>;
     createQueryCreator(): QueryCreator<any>;
-    createJoinBuilder(joinType: JoinType, tableNode: TableExpressionNode): JoinBuilder<any, any>;
 }
-export declare function createParseContext(adapter: DialectAdapter): ParseContext;

package/dist/esm/parser/parse-context.js

@@ -2,38 +2,45 @@ import { JoinNode } from '../operation-node/join-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
-import { SubQueryBuilder } from '../query-builder/sub-query-builder.js';
+import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
-import { freeze } from '../util/object-utils.js';
 import { createQueryId } from '../util/query-id.js';
-export function createParseContext(adapter) {
-    return freeze({
-        createEmptySelectQuery() {
-            return new QueryBuilder({
-                queryId: createQueryId(),
-                executor: new NoopQueryExecutor(),
-                queryNode: SelectQueryNode.create([]),
-                adapter,
-            });
-        },
-        createSubQueryBuilder() {
-            return new SubQueryBuilder({
-                executor: new NoopQueryExecutor(),
-                adapter,
-            });
-        },
-        createQueryCreator() {
-            return new QueryCreator({
-                executor: new NoopQueryExecutor(),
-                adapter,
-            });
-        },
-        createJoinBuilder(joinType, tableNode) {
-            return new JoinBuilder({
-                joinNode: JoinNode.create(joinType, tableNode),
-                adapter,
-            });
-        },
-    });
+import { parseTableExpression, parseTableExpressionOrList, } from './table-parser.js';
+export class DefaultParseContext {
+    #adapter;
+    #noopExecutor;
+    constructor(adapter) {
+        this.#adapter = adapter;
+        this.#noopExecutor = new NoopQueryExecutor();
+    }
+    get adapter() {
+        return this.#adapter;
+    }
+    createSelectQueryBuilder(tables) {
+        return new QueryBuilder({
+            queryId: createQueryId(),
+            executor: this.#noopExecutor,
+            parseContext: this,
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this, tables)),
+        });
+    }
+    createJoinBuilder(joinType, table) {
+        return new JoinBuilder({
+            joinNode: JoinNode.create(joinType, parseTableExpression(this, table)),
+            parseContext: this,
+        });
+    }
+    createExpressionBuilder() {
+        return new ExpressionBuilder({
+            executor: this.#noopExecutor,
+            parseContext: this,
+        });
+    }
+    createQueryCreator() {
+        return new QueryCreator({
+            executor: this.#noopExecutor,
+            parseContext: this,
+        });
+    }
 }

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

@@ -14,7 +14,7 @@ export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB,
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, arg: ReferenceExpression<any, any>): ReferenceExpressionNode;
-export declare function parseStringReference(str: string): ColumnNode | ReferenceNode;
-export declare function parseAliasedStringReference(str: string): ColumnNode | ReferenceNode | AliasNode;
+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;
 export {};

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

@@ -24,16 +24,17 @@ export function parseReferenceExpression(ctx, arg) {
         }
     }
     else if (isFunction(arg)) {
-        const node = arg(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
         if (!QueryNode.isMutating(node)) {
             return node;
         }
     }
     throw new Error(`invalid reference expression ${JSON.stringify(arg)}`);
 }
-export function parseStringReference(str) {
-    if (str.includes('.')) {
-        const parts = str.split('.').map((it) => it.trim());
+export function parseStringReference(ref) {
+    const COLUMN_SEPARATOR = '.';
+    if (ref.includes(COLUMN_SEPARATOR)) {
+        const parts = ref.split(COLUMN_SEPARATOR).map(trim);
         if (parts.length === 3) {
             return parseStringReferenceWithTableAndSchema(parts);
         }
@@ -41,21 +42,21 @@ export function parseStringReference(str) {
             return parseStringReferenceWithTable(parts);
         }
         else {
-            throw new Error(`invalid column reference ${str}`);
+            throw new Error(`invalid column reference ${ref}`);
         }
     }
     else {
-        return ColumnNode.create(str);
+        return ColumnNode.create(ref);
     }
 }
-export function parseAliasedStringReference(str) {
-    if (str.includes(' as ')) {
-        const [tableColumn, alias] = str.split(' as ').map((it) => it.trim());
-        const tableColumnNode = parseStringReference(tableColumn);
-        return AliasNode.create(tableColumnNode, alias);
+export function parseAliasedStringReference(ref) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (ref.includes(ALIAS_SEPARATOR)) {
+        const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
+        return AliasNode.create(parseStringReference(columnRef), alias);
     }
     else {
-        return parseStringReference(str);
+        return parseStringReference(ref);
     }
 }
 export function parseColumnName(column) {
@@ -69,3 +70,6 @@ function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
     return ReferenceNode.create(TableNode.create(table), ColumnNode.create(column));
 }
+function trim(str) {
+    return str.trim();
+}

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

@@ -26,6 +26,5 @@ declare type ExtractAliasFromStringSelectExpression<S extends string> = S extend
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, S, A extends keyof any> = S extends string ? ExtractTypeFromStringSelectExpression<DB, TB, S, A> : S extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, S extends string, A extends keyof any, R = RowType<DB, TB>> = S 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 : S 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 : S extends `${infer C} as ${infer RA}` ? RA extends A ? C extends keyof R ? R[C] : never : never : S 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 : S extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : S extends A ? S extends keyof R ? R[S] : never : never;
 export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
-export declare function parseSelectAllArgs(table?: string | string[]): SelectionNode[];
-export declare function parseSelectAllArg(table: string): SelectionNode;
+export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

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

@@ -18,13 +18,13 @@ function parseSelectExpression(ctx, selection) {
         return SelectionNode.create(selection.toOperationNode());
     }
     else if (isFunction(selection)) {
-        return SelectionNode.create(selection(ctx.createSubQueryBuilder()).toOperationNode());
+        return SelectionNode.create(selection(ctx.createExpressionBuilder()).toOperationNode());
     }
     else {
         throw new Error(`invalid value passed to select method: ${JSON.stringify(selection)}`);
     }
 }
-export function parseSelectAllArgs(table) {
+export function parseSelectAll(table) {
     if (!table) {
         return [SelectionNode.createSelectAll()];
     }
@@ -35,7 +35,7 @@ export function parseSelectAllArgs(table) {
         return [parseSelectAllArg(table)];
     }
 }
-export function parseSelectAllArg(table) {
+function parseSelectAllArg(table) {
     if (isString(table)) {
         return SelectionNode.createSelectAllFromTable(table);
     }

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

@@ -18,27 +18,32 @@ export function parseTableExpression(ctx, table) {
         return table.toOperationNode();
     }
     else if (isFunction(table)) {
-        return table(ctx.createSubQueryBuilder()).toOperationNode();
+        return table(ctx.createExpressionBuilder()).toOperationNode();
     }
     else {
         throw new Error(`invalid table expression ${JSON.stringify(table)}`);
     }
 }
 export function parseAliasedTable(from) {
-    const [table, alias] = from.split(' as ').map((it) => it.trim());
-    if (alias) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
         return AliasNode.create(parseTable(table), alias);
     }
     else {
-        return parseTable(table);
+        return parseTable(from);
     }
 }
 export function parseTable(from) {
-    if (from.includes('.')) {
-        const [schema, table] = from.split('.').map((it) => it.trim());
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
         return TableNode.createWithSchema(schema, table);
     }
     else {
         return TableNode.create(from);
     }
 }
+function trim(str) {
+    return str.trim();
+}

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

@@ -20,7 +20,7 @@ export function parseMutationValueExpression(ctx, value) {
         }
     }
     else if (isFunction(value)) {
-        const node = value(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = value(ctx.createExpressionBuilder()).toOperationNode();
         if (!QueryNode.isMutating(node)) {
             return node;
         }

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

@@ -24,7 +24,7 @@ export function parseValueExpression(ctx, arg) {
         }
     }
     else if (isFunction(arg)) {
-        const node = arg(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
         if (!QueryNode.isMutating(node)) {
             return node;
         }

package/dist/esm/query-builder/{sub-query-builder.d.ts → expression-builder.d.ts}

@@ -1,9 +1,9 @@
 import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
-import { DialectAdapter } from '../dialect/dialect-adapter.js';
-export declare class SubQueryBuilder<DB, TB extends keyof DB> {
+import { ParseContext } from '../parser/parse-context.js';
+export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
-    constructor(props: SubQueryBuilderProps);
+    constructor(props: ExpressionBuilderProps);
     /**
      * Creates a subquery.
      *
@@ -50,9 +50,9 @@ export declare class SubQueryBuilder<DB, TB extends keyof DB> {
     /**
      * See {@link QueryCreator.withSchema}
      */
-    withSchema(schema: string): SubQueryBuilder<DB, TB>;
+    withSchema(schema: string): ExpressionBuilder<DB, TB>;
 }
-export interface SubQueryBuilderProps {
+export interface ExpressionBuilderProps {
     readonly executor: NoopQueryExecutor;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }

package/dist/esm/query-builder/{sub-query-builder.js → expression-builder.js}

@@ -4,8 +4,7 @@ import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { freeze } from '../util/object-utils.js';
-import { createParseContext } from '../parser/parse-context.js';
-export class SubQueryBuilder {
+export class ExpressionBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
@@ -14,20 +13,17 @@ export class SubQueryBuilder {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#parseContext, table)),
+            parseContext: this.#props.parseContext,
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#props.parseContext, table)),
         });
     }
     /**
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema) {
-        return new SubQueryBuilder({
+        return new ExpressionBuilder({
             ...this.#props,
             executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
         });
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }

package/dist/esm/query-builder/join-builder.d.ts

@@ -1,7 +1,7 @@
-import { DialectAdapter } from '../dialect/dialect-adapter.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
+import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -69,5 +69,5 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
 }
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }

package/dist/esm/query-builder/join-builder.js

@@ -1,6 +1,5 @@
 import { JoinNode } from '../operation-node/join-node.js';
-import { parseExistExpression, parseNotExistExpression, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
-import { createParseContext } from '../parser/parse-context.js';
+import { parseExistFilter, parseNotExistFilter, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
@@ -11,13 +10,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -29,7 +28,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -41,7 +40,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -53,7 +52,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -65,7 +64,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -77,7 +76,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -89,14 +88,11 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {
         return this.#props.joinNode;
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }
 preventAwait(JoinBuilder, "don't await JoinBuilder instances. They are never executed directly and are always just a part of a query.");

package/dist/esm/query-builder/query-builder.d.ts

@@ -18,7 +18,7 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { OnConflictConstraintTarget } from '../parser/on-conflict-parser.js';
-import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { ParseContext } from '../parser/parse-context.js';
 /**
  * The main query builder class.
  *
@@ -1605,7 +1605,7 @@ export interface QueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: QueryNode;
     readonly executor: QueryExecutor;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }
 /**
  * {@link QueryBuilder} with an alias. The result of calling {@link QueryBuilder.as}.