kysely 0.16.11 → 0.17.0

package/README.md

@@ -20,8 +20,8 @@ much anything you can think of. Typescript is always there for you offering comp
 you build a valid query.
 
 Of course there are cases where things cannot be typed at compile time, and Kysely offers escape
-hatches for these situations. See the [DynamicModule](https://koskimas.github.io/kysely/classes/DynamicModule.html#ref)
-for more info.
+hatches for these situations. See the [sql template tag](https://koskimas.github.io/kysely/modules.html#sql) 
+and the [DynamicModule](https://koskimas.github.io/kysely/classes/DynamicModule.html#ref) for more info.
 
 If you start using Kysely and can't find something you'd want to use, please open an issue or join our
 [discord server](https://discord.gg/C9aJ49mCra).

package/dist/cjs/dialect/mysql/mysql-adapter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlAdapter = void 0;
+const sql_js_1 = require("../../raw-builder/sql.js");
 const dialect_adapter_base_js_1 = require("../dialect-adapter-base.js");
 const LOCK_ID = 'ea586330-2c93-47c8-908d-981d9d270f9d';
 const LOCK_TIMEOUT_SECONDS = 60 * 60;
@@ -18,12 +19,10 @@ class MysqlAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
         // is released using `release_lock`. This way we know that the lock is either
         // released by us after successfull or failed migrations OR it's released by
         // MySQL if the process gets killed for some reason.
-        await db
-            .raw(`select get_lock('${LOCK_ID}', ${LOCK_TIMEOUT_SECONDS})`)
-            .execute();
+        await (0, sql_js_1.sql) `select get_lock(${sql_js_1.sql.literal(LOCK_ID)}, ${sql_js_1.sql.literal(LOCK_TIMEOUT_SECONDS)})`.execute(db);
     }
     async releaseMigrationLock(db) {
-        await db.raw(`select release_lock('${LOCK_ID}')`).execute();
+        await (0, sql_js_1.sql) `select release_lock(${sql_js_1.sql.literal(LOCK_ID)})`.execute(db);
     }
 }
 exports.MysqlAdapter = MysqlAdapter;

package/dist/cjs/dialect/mysql/mysql-introspector.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlIntrospector = void 0;
 const migrator_js_1 = require("../../migration/migrator.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const sql_js_1 = require("../../raw-builder/sql.js");
 class MysqlIntrospector {
     #db;
     constructor(db) {
@@ -12,7 +13,7 @@ class MysqlIntrospector {
         let query = this.#db
             .selectFrom('information_schema.columns')
             .selectAll()
-            .where('table_schema', '=', this.#db.raw('database()'))
+            .where('table_schema', '=', (0, sql_js_1.sql) `database()`)
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query

package/dist/cjs/dialect/postgres/postgres-adapter.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresAdapter = void 0;
+const sql_js_1 = require("../../raw-builder/sql.js");
 const dialect_adapter_base_js_1 = require("../dialect-adapter-base.js");
 // Random id for our transaction lock.
-const LOCK_ID = '3853314791062309107';
+const LOCK_ID = 3853314791062309107n;
 class PostgresAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     get supportsTransactionalDdl() {
         return true;
@@ -13,7 +14,7 @@ class PostgresAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     }
     async acquireMigrationLock(db) {
         // Acquire a transaction level advisory lock.
-        await db.raw(`select pg_advisory_xact_lock(${LOCK_ID})`).execute();
+        await (0, sql_js_1.sql) `select pg_advisory_xact_lock(${sql_js_1.sql.literal(LOCK_ID)})`.execute(db);
     }
     async releaseMigrationLock() {
         // Nothing to do here. `pg_advisory_xact_lock` is automatically released at the

package/dist/cjs/dialect/sqlite/sqlite-introspector.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteIntrospector = void 0;
 const migrator_js_1 = require("../../migration/migrator.js");
+const sql_js_1 = require("../../raw-builder/sql.js");
 class SqliteIntrospector {
     #db;
     constructor(db) {
@@ -27,7 +28,7 @@ class SqliteIntrospector {
     async #getTableMetadata(table) {
         const db = this.#db;
         const columns = await db
-            .selectFrom(db.raw(`PRAGMA_TABLE_INFO(?)`, [table]).as('table_info'))
+            .selectFrom((0, sql_js_1.sql) `PRAGMA_TABLE_INFO(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull'])
             .castTo()
             .execute();

package/dist/cjs/index-nodeless.d.ts

@@ -17,9 +17,11 @@ export * from './query-builder/delete-result.js';
 export * from './query-builder/update-result.js';
 export * from './query-builder/on-conflict-builder.js';
 export * from './raw-builder/raw-builder.js';
+export * from './raw-builder/sql.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
 export * from './query-executor/noop-query-executor.js';
+export * from './query-executor/query-executor-provider.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/compiled-query.js';
 export * from './schema/schema.js';

package/dist/cjs/index-nodeless.js

@@ -29,9 +29,11 @@ __exportStar(require("./query-builder/delete-result.js"), exports);
 __exportStar(require("./query-builder/update-result.js"), exports);
 __exportStar(require("./query-builder/on-conflict-builder.js"), exports);
 __exportStar(require("./raw-builder/raw-builder.js"), exports);
+__exportStar(require("./raw-builder/sql.js"), exports);
 __exportStar(require("./query-executor/query-executor.js"), exports);
 __exportStar(require("./query-executor/default-query-executor.js"), exports);
 __exportStar(require("./query-executor/noop-query-executor.js"), exports);
+__exportStar(require("./query-executor/query-executor-provider.js"), exports);
 __exportStar(require("./query-compiler/default-query-compiler.js"), exports);
 __exportStar(require("./query-compiler/compiled-query.js"), exports);
 __exportStar(require("./schema/schema.js"), exports);

package/dist/cjs/kysely.d.ts

@@ -6,11 +6,9 @@ import { QueryCreator } from './query-creator.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { DatabaseIntrospector } from './dialect/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
-import { ParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
 import { LogConfig } from './util/log.js';
-import { PRIVATE_ADAPTER } from './util/private-symbols.js';
-import { DialectAdapter } from './dialect/dialect-adapter.js';
+import { QueryExecutorProvider } from './query-executor/query-executor-provider.js';
 /**
  * The main Kysely class.
  *
@@ -54,7 +52,7 @@ import { DialectAdapter } from './dialect/dialect-adapter.js';
  *    in the database and values must be interfaces that describe the rows in those
  *    tables. See the examples above.
  */
-export declare class Kysely<DB> extends QueryCreator<DB> {
+export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecutorProvider {
     #private;
     constructor(args: KyselyConfig);
     constructor(args: KyselyProps);
@@ -226,7 +224,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * @internal
      * @private
      */
-    get [PRIVATE_ADAPTER](): DialectAdapter;
+    getExecutor(): QueryExecutor;
 }
 export declare class Transaction<DB> extends Kysely<DB> {
     #private;
@@ -357,7 +355,6 @@ export interface KyselyProps {
     readonly driver: Driver;
     readonly executor: QueryExecutor;
     readonly dialect: Dialect;
-    readonly parseContext: ParseContext;
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {

package/dist/cjs/kysely.js

@@ -11,10 +11,8 @@ 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");
 const function_builder_js_1 = require("./query-builder/function-builder.js");
 const log_js_1 = require("./util/log.js");
-const private_symbols_js_1 = require("./util/private-symbols.js");
 /**
  * The main Kysely class.
  *
@@ -64,7 +62,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
         let superProps;
         let props;
         if (isKyselyProps(args)) {
-            superProps = { executor: args.executor, parseContext: args.parseContext };
+            superProps = { executor: args.executor };
             props = { ...args };
         }
         else {
@@ -73,17 +71,15 @@ class Kysely extends query_creator_js_1.QueryCreator {
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
             const log = new log_js_1.Log(args.log ?? []);
-            const parseContext = new parse_context_js_1.DefaultParseContext(adapter);
             const runtimeDriver = new runtime_driver_js_1.RuntimeDriver(driver, log);
             const connectionProvider = new default_connection_provider_js_1.DefaultConnectionProvider(runtimeDriver);
-            const executor = new default_query_executor_js_1.DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
-            superProps = { executor, parseContext };
+            const executor = new default_query_executor_js_1.DefaultQueryExecutor(compiler, adapter, connectionProvider, args.plugins ?? []);
+            superProps = { executor };
             props = {
                 config: args,
                 executor,
                 dialect,
                 driver: runtimeDriver,
-                parseContext,
             };
         }
         super(superProps);
@@ -139,7 +135,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * ```
      */
     get fn() {
-        return new function_builder_js_1.FunctionBuilder({ executor: this.#props.executor });
+        return new function_builder_js_1.FunctionBuilder();
     }
     /**
      * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
@@ -285,8 +281,8 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * @internal
      * @private
      */
-    get [private_symbols_js_1.PRIVATE_ADAPTER]() {
-        return this.#props.parseContext.adapter;
+    getExecutor() {
+        return this.#props.executor;
     }
 }
 exports.Kysely = Kysely;
@@ -333,8 +329,7 @@ function isKyselyProps(obj) {
         (0, object_utils_js_1.isObject)(obj.config) &&
         (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.parseContext));
+        (0, object_utils_js_1.isObject)(obj.dialect));
 }
 exports.isKyselyProps = isKyselyProps;
 class ConnectionBuilder {

package/dist/cjs/migration/migrator.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Migrator = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const private_symbols_js_1 = require("../util/private-symbols.js");
 exports.MIGRATION_TABLE = 'kysely_migration';
 exports.MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 exports.MIGRATION_LOCK_ID = 'migration_lock';
@@ -262,9 +261,10 @@ class Migrator {
         return !!lockRow;
     }
     async #runMigrations(getTargetMigrationIndex) {
+        const adapter = this.#props.db.getExecutor().adapter;
         const run = async (db) => {
             try {
-                await this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].acquireMigrationLock(db);
+                await adapter.acquireMigrationLock(db);
                 const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
@@ -282,10 +282,10 @@ class Migrator {
                 return { results: [] };
             }
             finally {
-                await this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].releaseMigrationLock(db);
+                await adapter.releaseMigrationLock(db);
             }
         };
-        if (this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].supportsTransactionalDdl) {
+        if (adapter.supportsTransactionalDdl) {
             return this.#props.db.transaction().execute(run);
         }
         else {

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

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

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

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

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

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

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

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

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

@@ -3,22 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isComplexExpression = exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-function parseComplexExpression(ctx, exp) {
+const parse_utils_js_1 = require("./parse-utils.js");
+function parseComplexExpression(exp) {
     if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
         return exp.toOperationNode();
     }
     else if ((0, object_utils_js_1.isFunction)(exp)) {
-        return exp(ctx.createExpressionBuilder()).toOperationNode();
+        return exp((0, parse_utils_js_1.createExpressionBuilder)()).toOperationNode();
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
 exports.parseComplexExpression = parseComplexExpression;
-function parseAliasedComplexExpression(ctx, exp) {
+function parseAliasedComplexExpression(exp) {
     if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
         return exp.toOperationNode();
     }
     else if ((0, object_utils_js_1.isFunction)(exp)) {
-        return exp(ctx.createExpressionBuilder()).toOperationNode();
+        return exp((0, parse_utils_js_1.createExpressionBuilder)()).toOperationNode();
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }

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

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

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

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

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

@@ -1,4 +1,3 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
-import { ParseContext } from './parse-context.js';
 import { ReferenceExpressionOrList } from './reference-parser.js';
-export declare function parseGroupBy(ctx: ParseContext, orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];
+export declare function parseGroupBy(orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGroupBy = void 0;
 const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
-function parseGroupBy(ctx, orderBy) {
-    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(ctx, orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
+function parseGroupBy(orderBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
 }
 exports.parseGroupBy = parseGroupBy;

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

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

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

@@ -8,15 +8,15 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
 const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
-function parseInsertObjectOrList(ctx, args) {
-    return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
+function parseInsertObjectOrList(args) {
+    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
 exports.parseInsertObjectOrList = parseInsertObjectOrList;
-function parseInsertColumnsAndValues(ctx, rows) {
+function parseInsertColumnsAndValues(rows) {
     const columns = parseColumnNamesAndIndexes(rows);
     return [
         (0, object_utils_js_1.freeze)([...columns.keys()].map(column_node_js_1.ColumnNode.create)),
-        values_node_js_1.ValuesNode.create(rows.map((row) => parseRowValues(ctx, row, columns))),
+        values_node_js_1.ValuesNode.create(rows.map((row) => parseRowValues(row, columns))),
     ];
 }
 function parseColumnNamesAndIndexes(rows) {
@@ -31,7 +31,7 @@ function parseColumnNamesAndIndexes(rows) {
     }
     return columns;
 }
-function parseRowValues(ctx, row, columns) {
+function parseRowValues(row, columns) {
     const rowColumns = Object.keys(row);
     const rowValues = new Array(columns.size).fill(null);
     for (const col of rowColumns) {
@@ -42,7 +42,7 @@ function parseRowValues(ctx, row, columns) {
         }
     }
     if (rowValues.some(complex_expression_parser_js_1.isComplexExpression)) {
-        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(ctx, it)));
+        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, value_parser_js_1.parseValueExpression)(it)));
     }
     return primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues);
 }

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

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

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

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