kysely 0.7.1 → 0.7.5

package/dist/esm/operation-node/on-conflict-node.d.ts

@@ -2,7 +2,7 @@ import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type OnConflictNodeParams = Omit<OnConflictNode, 'kind'>;
+export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
@@ -15,5 +15,5 @@ export interface OnConflictNode extends OperationNode {
  */
 export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
-    create(params: OnConflictNodeParams): OnConflictNode;
+    create(props: OnConflictNodeProps): OnConflictNode;
 }>;

package/dist/esm/operation-node/on-conflict-node.js

@@ -6,10 +6,10 @@ export const OnConflictNode = freeze({
     is(node) {
         return node.kind === 'OnConflictNode';
     },
-    create(params) {
+    create(props) {
         return freeze({
             kind: 'OnConflictNode',
-            ...params,
+            ...props,
         });
     },
 });

package/dist/esm/operation-node/on-duplicate-key-node.d.ts

@@ -0,0 +1,14 @@
+import { ColumnUpdateNode } from './column-update-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>;
+export interface OnDuplicateKeyNode extends OperationNode {
+    readonly kind: 'OnDuplicateKeyNode';
+    readonly updates: ReadonlyArray<ColumnUpdateNode>;
+}
+/**
+ * @internal
+ */
+export declare const OnDuplicateKeyNode: Readonly<{
+    is(node: OperationNode): node is OnDuplicateKeyNode;
+    create(updates: ReadonlyArray<ColumnUpdateNode>): OnDuplicateKeyNode;
+}>;

package/dist/esm/operation-node/on-duplicate-key-node.js

@@ -0,0 +1,15 @@
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const OnDuplicateKeyNode = freeze({
+    is(node) {
+        return node.kind === 'OnDuplicateKeyNode';
+    },
+    create(updates) {
+        return freeze({
+            kind: 'OnDuplicateKeyNode',
+            updates,
+        });
+    },
+});

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

@@ -56,6 +56,7 @@ import { DropConstraintNode } from './drop-constraint-node.js';
 import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -121,6 +122,7 @@ export declare class OperationNodeTransformer {
     protected transformLimit(node: LimitNode): LimitNode;
     protected transformOffset(node: OffsetNode): OffsetNode;
     protected transformOnConflict(node: OnConflictNode): OnConflictNode;
+    protected transformOnDuplicateKey(node: OnDuplicateKeyNode): OnDuplicateKeyNode;
     protected transformCreateIndex(node: CreateIndexNode): CreateIndexNode;
     protected transformList(node: ListNode): ListNode;
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;

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

@@ -68,6 +68,7 @@ export class OperationNodeTransformer {
         LimitNode: this.transformLimit.bind(this),
         OffsetNode: this.transformOffset.bind(this),
         OnConflictNode: this.transformOnConflict.bind(this),
+        OnDuplicateKeyNode: this.transformOnDuplicateKey.bind(this),
         CreateIndexNode: this.transformCreateIndex.bind(this),
         DropIndexNode: this.transformDropIndex.bind(this),
         ListNode: this.transformList.bind(this),
@@ -224,7 +225,9 @@ export class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
+            onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
+            ignore: node.ignore,
         };
     }
     transformDeleteQuery(node) {
@@ -343,6 +346,12 @@ export class OperationNodeTransformer {
             doNothing: node.doNothing,
         };
     }
+    transformOnDuplicateKey(node) {
+        return {
+            kind: 'OnDuplicateKeyNode',
+            updates: this.transformNodeList(node.updates),
+        };
+    }
     transformCreateIndex(node) {
         return {
             kind: 'CreateIndexNode',
@@ -387,6 +396,8 @@ export class OperationNodeTransformer {
             columns: this.transformNodeList(node.columns),
             references: this.transformNode(node.references),
             name: this.transformNode(node.name),
+            onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformReferences(node) {
@@ -395,6 +406,7 @@ export class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformCheckConstraint(node) {

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

@@ -56,6 +56,7 @@ import { DropConstraintNode } from './drop-constraint-node.js';
 import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 export declare class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -91,6 +92,7 @@ export declare class OperationNodeVisitor {
     protected visitLimit(node: LimitNode): void;
     protected visitOffset(node: OffsetNode): void;
     protected visitOnConflict(node: OnConflictNode): void;
+    protected visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
     protected visitCreateIndex(node: CreateIndexNode): void;
     protected visitList(node: ListNode): void;
     protected visitDropIndex(node: DropIndexNode): void;

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

@@ -38,6 +38,7 @@ export class OperationNodeVisitor {
         LimitNode: this.visitLimit.bind(this),
         OffsetNode: this.visitOffset.bind(this),
         OnConflictNode: this.visitOnConflict.bind(this),
+        OnDuplicateKeyNode: this.visitOnDuplicateKey.bind(this),
         CreateIndexNode: this.visitCreateIndex.bind(this),
         DropIndexNode: this.visitDropIndex.bind(this),
         ListNode: this.visitList.bind(this),
@@ -262,6 +263,9 @@ export class OperationNodeVisitor {
             node.updates.forEach(this.visitNode);
         }
     }
+    visitOnDuplicateKey(node) {
+        node.updates.forEach(this.visitNode);
+    }
     visitCreateIndex(node) {
         this.visitNode(node.name);
         if (node.table) {

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,12 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
-export declare type OnDelete = 'cascade' | 'set null';
+export declare type OnModifyForeignAction = 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default';
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnNode>;
-    readonly onDelete?: OnDelete;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
 }
 /**
  * @internal
@@ -14,5 +15,6 @@ export interface ReferencesNode extends OperationNode {
 export declare const ReferencesNode: Readonly<{
     is(node: OperationNode): node is ReferencesNode;
     create(table: TableNode, columns: ReadonlyArray<ColumnNode>): ReferencesNode;
-    cloneWithOnDelete(references: ReferencesNode, onDelete: OnDelete): ReferencesNode;
+    cloneWithOnDelete(references: ReferencesNode, onDelete: OnModifyForeignAction): ReferencesNode;
+    cloneWithOnUpdate(references: ReferencesNode, onUpdate: OnModifyForeignAction): ReferencesNode;
 }>;

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

@@ -19,4 +19,10 @@ export const ReferencesNode = freeze({
             onDelete,
         });
     },
+    cloneWithOnUpdate(references, onUpdate) {
+        return freeze({
+            ...references,
+            onUpdate,
+        });
+    },
 });

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

@@ -8,10 +8,10 @@ export const TableNode = freeze({
         return node.kind === 'TableNode';
     },
     create(table) {
-        return {
+        return freeze({
             kind: 'TableNode',
             table: IdentifierNode.create(table),
-        };
+        });
     },
     createWithSchema(schema, table) {
         return freeze({

package/dist/esm/parser/data-type-parser.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDataType, DataTypeNode } from '../operation-node/data-type-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+export declare type DataTypeExpression = ColumnDataType | AnyRawBuilder;
+export declare function parseDataTypeExpression(dataType: DataTypeExpression): DataTypeNode | RawNode;

package/dist/esm/parser/data-type-parser.js

@@ -0,0 +1,7 @@
+import { DataTypeNode, } from '../operation-node/data-type-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+export function parseDataTypeExpression(dataType) {
+    return isOperationNodeSource(dataType)
+        ? dataType.toOperationNode()
+        : DataTypeNode.create(dataType);
+}

package/dist/esm/parser/default-value-parser.d.ts

@@ -0,0 +1,6 @@
+import { RawNode } from '../operation-node/raw-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+export declare type DefaultValueExpression = PrimitiveValue | AnyRawBuilder;
+export declare function parseDefaultValueExpression(value: DefaultValueExpression): ValueNode | RawNode;

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

@@ -0,0 +1,7 @@
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { ValueNode } from '../operation-node/value-node.js';
+export function parseDefaultValueExpression(value) {
+    return isOperationNodeSource(value)
+        ? value.toOperationNode()
+        : ValueNode.createImmediate(value);
+}

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

@@ -10,5 +10,5 @@ export declare function parseWhereFilter(ctx: ParseContext, args: any[]): Filter
 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 parseExistExpression(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseNotExistExpression(ctx: ParseContext, arg: ExistsExpression<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;

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 '../index.js';
+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

@@ -1,38 +1,46 @@
-import { NoopQueryExecutor, SelectQueryNode } from '../index.js';
 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 { freeze } from '../util/object-utils.js';
+import { NoopQueryExecutor } from '../query-executor/noop-query-executor.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 {};