kysely 0.7.2 → 0.7.6

package/README.md

@@ -24,11 +24,15 @@ fail you. With Kysely you can also explicitly tell it to ignore the typings, but
 type-safety! See the [DynamicModule](https://koskimas.github.io/kysely/classes/DynamicModule.html#ref)
 for more info.
 
-Kysely is still young and some useful methods and modules are not yet implemented. If you start using
-Kysely, please open an issue as soon as you can't find something you want to use.
+Kysely is still young and some useful features are propably not yet implemented. If you start
+using Kysely and can't find something you'd want to use, please open an issue.
 
-- [API reference](https://koskimas.github.io/kysely/index.html)
+# Table of contents
+
+- [Installation](#installation)
+- [Minimal example](#minimal-example)
 - [Migrations](#migrations)
+- [API reference](https://koskimas.github.io/kysely/index.html)
 
 # Installation
 
@@ -43,7 +47,7 @@ npm install kysely mysql2
 ```
 
 More dialects will be added soon. Kysely also has a simple interface
-for [third-party dialects](https://koskimas.github.io/kysely/interfaces/Dialect.html).
+for [3rd party dialects](https://koskimas.github.io/kysely/interfaces/Dialect.html).
 
 3rd party dialects:
 
@@ -76,7 +80,7 @@ interface Movie {
   stars: number
 }
 
-// Keys are table names.
+// Keys of this interface are table names.
 interface Database {
   person: Person
   pet: Pet

package/dist/cjs/dialect/dialect-adapter.d.ts

@@ -1,13 +1,5 @@
 import { Kysely } from '../kysely.js';
-/**
- * The `DialectAdapter` encapsulates all differences between dialects outside
- * the `Driver` and `QueryCompiler`.
- *
- * For example, some databases support transactional DDL and therefore we want
- * to run migrations inside a transaction, while other databases don't support
- * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
- */
-export interface DialectAdapter {
+export interface DialectSupports {
     /**
      * Whether or not this dialect supports transactional DDL.
      *
@@ -19,6 +11,16 @@ export interface DialectAdapter {
      * upates and deletes.
      */
     readonly supportsReturning: boolean;
+}
+/**
+ * The `DialectAdapter` encapsulates all differences between dialects outside
+ * the `Driver` and `QueryCompiler`.
+ *
+ * For example, some databases support transactional DDL and therefore we want
+ * to run migrations inside a transaction, while other databases don't support
+ * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
+ */
+export interface DialectAdapter extends DialectSupports {
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration processes to run in parallel.

package/dist/cjs/index.d.ts

@@ -2,7 +2,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/sub-query-builder.js';
+export * from './query-builder/expression-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -17,6 +17,7 @@ export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
 export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
+export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';

package/dist/cjs/index.js

@@ -14,7 +14,7 @@ __exportStar(require("./kysely.js"), exports);
 __exportStar(require("./query-creator.js"), exports);
 __exportStar(require("./query-builder/query-builder.js"), exports);
 __exportStar(require("./query-builder/join-builder.js"), exports);
-__exportStar(require("./query-builder/sub-query-builder.js"), exports);
+__exportStar(require("./query-builder/expression-builder.js"), exports);
 __exportStar(require("./raw-builder/raw-builder.js"), exports);
 __exportStar(require("./query-executor/query-executor.js"), exports);
 __exportStar(require("./query-executor/default-query-executor.js"), exports);
@@ -29,6 +29,7 @@ __exportStar(require("./schema/drop-index-builder.js"), exports);
 __exportStar(require("./schema/create-schema-builder.js"), exports);
 __exportStar(require("./schema/drop-schema-builder.js"), exports);
 __exportStar(require("./schema/column-definition-builder.js"), exports);
+__exportStar(require("./schema/foreign-key-constraint-builder.js"), exports);
 __exportStar(require("./schema/alter-table-builder.js"), exports);
 __exportStar(require("./dynamic/dynamic.js"), exports);
 __exportStar(require("./driver/driver.js"), exports);

package/dist/cjs/kysely.d.ts

@@ -8,7 +8,7 @@ import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { GeneratedPlaceholder } from './query-builder/type-utils.js';
 import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
-import { DialectAdapter } from './dialect/dialect-adapter.js';
+import { ParseContext } from './parser/parse-context.js';
 /**
  * The main Kysely class.
  *
@@ -186,7 +186,7 @@ export interface KyselyProps {
     readonly driver: Driver;
     readonly executor: QueryExecutor;
     readonly dialect: Dialect;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {

package/dist/cjs/kysely.js

@@ -13,6 +13,7 @@ const runtime_driver_js_1 = require("./driver/runtime-driver.js");
 const single_connection_provider_js_1 = require("./driver/single-connection-provider.js");
 const driver_js_1 = require("./driver/driver.js");
 const prevent_await_js_1 = require("./util/prevent-await.js");
+const parse_context_js_1 = require("./parser/parse-context.js");
 /**
  * The main Kysely class.
  *
@@ -57,7 +58,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
     #props;
     constructor(args) {
         if (isKyselyProps(args)) {
-            super({ executor: args.executor, adapter: args.adapter });
+            super({ executor: args.executor, parseContext: args.parseContext });
             this.#props = (0, object_utils_js_1.freeze)(args);
         }
         else {
@@ -65,16 +66,17 @@ class Kysely extends query_creator_js_1.QueryCreator {
             const driver = dialect.createDriver();
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
+            const parseContext = new parse_context_js_1.DefaultParseContext(adapter);
             const runtimeDriver = new runtime_driver_js_1.RuntimeDriver(driver);
             const connectionProvider = new default_connection_provider_js_1.DefaultConnectionProvider(runtimeDriver);
             const executor = new default_query_executor_js_1.DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
-            super({ executor, adapter });
+            super({ executor, parseContext });
             this.#props = (0, object_utils_js_1.freeze)({
                 config: args,
                 executor,
-                adapter,
                 dialect,
-                driver,
+                driver: runtimeDriver,
+                parseContext,
             });
         }
     }
@@ -88,7 +90,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * Returns the {@link MigrationModule} module for managing and running migrations.
      */
     get migration() {
-        return new migration_js_1.MigrationModule(this, this.#props.adapter);
+        return new migration_js_1.MigrationModule(this, this.#props.parseContext.adapter);
     }
     /**
      * Returns a the {@link DynamicModule} module.
@@ -248,7 +250,7 @@ function isKyselyProps(obj) {
         (0, object_utils_js_1.isObject)(obj.driver) &&
         (0, object_utils_js_1.isObject)(obj.executor) &&
         (0, object_utils_js_1.isObject)(obj.dialect) &&
-        (0, object_utils_js_1.isObject)(obj.adapter));
+        (0, object_utils_js_1.isObject)(obj.parseContext));
 }
 exports.isKyselyProps = isKyselyProps;
 class ConnectionBuilder {
@@ -276,7 +278,7 @@ exports.ConnectionBuilder = ConnectionBuilder;
 class TransactionBuilder {
     #props;
     constructor(props) {
-        this.#props = props;
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     setIsolationLevel(isolationLevel) {
         return new TransactionBuilder({

package/dist/cjs/operation-node/create-table-node.d.ts

@@ -1,5 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
+import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 export declare type CreateTableNodeModifier = 'IfNotExists';
@@ -21,5 +22,5 @@ export declare const CreateTableNode: Readonly<{
     cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithUniqueConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithCheckConstraint(createTable: CreateTableNode, constraintName: string, sql: string): CreateTableNode;
-    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraintName: string, sourceColumns: string[], targetTable: string, targetColumns: string[]): CreateTableNode;
+    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraint: ForeignKeyConstraintNode): CreateTableNode;
 }>;

package/dist/cjs/operation-node/create-table-node.js

@@ -3,11 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTableNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const check_constraint_node_js_1 = require("./check-constraint-node.js");
-const table_node_js_1 = require("./table-node.js");
 const primary_constraint_node_js_1 = require("./primary-constraint-node.js");
 const unique_constraint_node_js_1 = require("./unique-constraint-node.js");
-const foreign_key_constraint_node_js_1 = require("./foreign-key-constraint-node.js");
-const column_node_js_1 = require("./column-node.js");
 /**
  * @internal
  */
@@ -61,8 +58,7 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([constraint]),
         });
     },
-    cloneWithForeignKeyConstraint(createTable, constraintName, sourceColumns, targetTable, targetColumns) {
-        const constraint = foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(sourceColumns.map(column_node_js_1.ColumnNode.create), table_node_js_1.TableNode.create(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName);
+    cloneWithForeignKeyConstraint(createTable, constraint) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,
             constraints: createTable.constraints

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -1,12 +1,15 @@
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-import { ReferencesNode } from './references-node.js';
+import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
 import { TableNode } from './table-node.js';
+export declare type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly references: ReferencesNode;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
     readonly name?: IdentifierNode;
 }
 /**
@@ -15,4 +18,12 @@ export interface ForeignKeyConstraintNode extends OperationNode {
 export declare const ForeignKeyConstraintNode: Readonly<{
     is(node: OperationNode): node is ForeignKeyConstraintNode;
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string | undefined): ForeignKeyConstraintNode;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
+        name?: IdentifierNode | undefined;
+        onDelete?: OnModifyForeignAction | undefined;
+        onUpdate?: OnModifyForeignAction | undefined;
+        kind: 'ForeignKeyConstraintNode';
+        columns: ReadonlyArray<ColumnNode>;
+        references: ReferencesNode;
+    }>;
 }>;

package/dist/cjs/operation-node/foreign-key-constraint-node.js

@@ -19,4 +19,10 @@ exports.ForeignKeyConstraintNode = (0, object_utils_js_1.freeze)({
             name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
         });
     },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
 });

package/dist/cjs/operation-node/join-node.d.ts

@@ -20,5 +20,6 @@ export interface JoinNode extends OperationNode {
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
+    createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
     cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
 }>;

package/dist/cjs/operation-node/join-node.js

@@ -19,6 +19,14 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
             on: undefined,
         });
     },
+    createWithOn(joinType, table, on) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on,
+        });
+    },
     cloneWithOn(joinNode, op, on) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,

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

@@ -399,6 +399,8 @@ 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) {
@@ -407,6 +409,7 @@ class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformCheckConstraint(node) {

package/dist/cjs/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/cjs/operation-node/references-node.js

@@ -22,4 +22,10 @@ exports.ReferencesNode = (0, object_utils_js_1.freeze)({
             onDelete,
         });
     },
+    cloneWithOnUpdate(references, onUpdate) {
+        return (0, object_utils_js_1.freeze)({
+            ...references,
+            onUpdate,
+        });
+    },
 });

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

@@ -11,10 +11,10 @@ exports.TableNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'TableNode';
     },
     create(table) {
-        return {
+        return (0, object_utils_js_1.freeze)({
             kind: 'TableNode',
             table: identifier_node_js_1.IdentifierNode.create(table),
-        };
+        });
     },
     createWithSchema(schema, table) {
         return (0, object_utils_js_1.freeze)({

package/dist/cjs/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/cjs/parser/data-type-parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDataTypeExpression = void 0;
+const data_type_node_js_1 = require("../operation-node/data-type-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+function parseDataTypeExpression(dataType) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(dataType)
+        ? dataType.toOperationNode()
+        : data_type_node_js_1.DataTypeNode.create(dataType);
+}
+exports.parseDataTypeExpression = parseDataTypeExpression;

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

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

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNotExistExpression = exports.parseExistExpression = exports.parseReferenceFilter = exports.parseOnFilter = exports.parseHavingFilter = exports.parseWhereFilter = void 0;
+exports.parseNotExistFilter = exports.parseExistFilter = exports.parseReferenceFilter = exports.parseOnFilter = exports.parseHavingFilter = exports.parseWhereFilter = void 0;
 const filter_node_js_1 = require("../operation-node/filter-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
@@ -11,13 +11,12 @@ const reference_parser_js_1 = require("./reference-parser.js");
 const value_parser_js_1 = require("./value-parser.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
-const table_parser_js_1 = require("./table-parser.js");
 function parseWhereFilter(ctx, args) {
     if (args.length === 3) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && (0, object_utils_js_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)}`);
@@ -29,7 +28,7 @@ function parseHavingFilter(ctx, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && (0, object_utils_js_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)}`);
@@ -41,7 +40,7 @@ function parseOnFilter(ctx, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1 && (0, object_utils_js_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)}`);
@@ -52,23 +51,14 @@ function parseReferenceFilter(ctx, lhs, op, rhs) {
     return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, lhs), parseFilterOperator(op), (0, reference_parser_js_1.parseReferenceExpression)(ctx, rhs));
 }
 exports.parseReferenceFilter = parseReferenceFilter;
-function parseExistExpression(ctx, arg) {
-    return doParseExistExpression(ctx, 'exists', arg);
+function parseExistFilter(ctx, arg) {
+    return parseExistExpression(ctx, 'exists', arg);
 }
-exports.parseExistExpression = parseExistExpression;
-function parseNotExistExpression(ctx, arg) {
-    return doParseExistExpression(ctx, 'not exists', arg);
-}
-exports.parseNotExistExpression = parseNotExistExpression;
-function doParseExistExpression(ctx, type, arg) {
-    const node = (0, object_utils_js_1.isFunction)(arg)
-        ? arg(ctx.createSubQueryBuilder()).toOperationNode()
-        : arg.toOperationNode();
-    if (!select_query_node_js_1.SelectQueryNode.is(node) && !raw_node_js_1.RawNode.is(node)) {
-        throw new Error('invalid where exists arg');
-    }
-    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), node);
+exports.parseExistFilter = parseExistFilter;
+function parseNotExistFilter(ctx, arg) {
+    return parseExistExpression(ctx, 'not exists', arg);
 }
+exports.parseNotExistFilter = parseNotExistFilter;
 function parseThreeArgFilter(ctx, left, op, right) {
     if ((op === 'is' || op === 'is not') && ((0, object_utils_js_1.isNull)(right) || (0, object_utils_js_1.isBoolean)(right))) {
         return parseIsFilter(ctx, left, op, right);
@@ -79,38 +69,46 @@ function parseIsFilter(ctx, left, op, right) {
     return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, left), parseFilterOperator(op), value_node_js_1.ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
-    if ((0, operation_node_source_js_1.isOperationNodeSource)(op)) {
-        return op.toOperationNode();
-    }
-    else if ((0, object_utils_js_1.isString)(op)) {
-        const opString = op.trim().toLowerCase();
-        if (operator_node_js_1.OPERATORS.some((it) => it === opString)) {
-            return operator_node_js_1.OperatorNode.create(opString);
+    if ((0, object_utils_js_1.isString)(op)) {
+        if (operator_node_js_1.OPERATORS.includes(op)) {
+            return operator_node_js_1.OperatorNode.create(op);
         }
     }
+    else if ((0, operation_node_source_js_1.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 parens_node_js_1.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 parens_node_js_1.ParensNode.create(queryNode.having.having);
 }
-function parseOnGrouper(ctx, grouper) {
-    const joinBuilder = grouper(ctx.createJoinBuilder('InnerJoin', (0, table_parser_js_1.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 parens_node_js_1.ParensNode.create(joinNode.on);
 }
+function parseExistExpression(ctx, type, arg) {
+    const node = (0, object_utils_js_1.isFunction)(arg)
+        ? arg(ctx.createExpressionBuilder()).toOperationNode()
+        : arg.toOperationNode();
+    if (!select_query_node_js_1.SelectQueryNode.is(node) && !raw_node_js_1.RawNode.is(node)) {
+        throw new Error('invalid where exists arg');
+    }
+    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), node);
+}

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

@@ -1,27 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJoinArgs = void 0;
+exports.parseJoin = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const table_parser_js_1 = require("./table-parser.js");
 const filter_parser_js_1 = require("./filter-parser.js");
-function parseJoinArgs(ctx, joinType, args) {
-    if (args.length === 2) {
-        return parseCallbackJoin(ctx, joinType, args[0], args[1]);
-    }
-    else if (args.length === 3) {
+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');
     }
 }
-exports.parseJoinArgs = parseJoinArgs;
+exports.parseJoin = parseJoin;
 function parseCallbackJoin(ctx, joinType, from, callback) {
-    const tableNode = (0, table_parser_js_1.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 = (0, table_parser_js_1.parseTableExpression)(ctx, from);
-    return join_node_js_1.JoinNode.cloneWithOn(join_node_js_1.JoinNode.create(joinType, tableNode), 'And', (0, filter_parser_js_1.parseReferenceFilter)(ctx, lhsColumn, '=', rhsColumn));
+    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(ctx, from), (0, filter_parser_js_1.parseReferenceFilter)(ctx, lhsColumn, '=', rhsColumn));
 }

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