kysely 0.16.8 → 0.17.0

package/dist/esm/query-creator.js

@@ -8,7 +8,6 @@ import { InsertQueryNode } from './operation-node/insert-query-node.js';
 import { SelectQueryNode } from './operation-node/select-query-node.js';
 import { UpdateQueryNode } from './operation-node/update-query-node.js';
 import { parseTable, parseTableExpression, parseTableExpressionOrList, } from './parser/table-parser.js';
-import { RawBuilder } from './raw-builder/raw-builder.js';
 import { parseCommonTableExpression, } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
@@ -23,8 +22,7 @@ export class QueryCreator {
         return new SelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#props.parseContext, from), this.#props.withNode),
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode),
         });
     }
     /**
@@ -69,7 +67,6 @@ export class QueryCreator {
         return new InsertQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
@@ -96,8 +93,7 @@ export class QueryCreator {
         return new DeleteQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: DeleteQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
+            queryNode: DeleteQueryNode.create(parseTableExpression(table), this.#props.withNode),
         });
     }
     /**
@@ -127,8 +123,7 @@ export class QueryCreator {
         return new UpdateQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: UpdateQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
+            queryNode: UpdateQueryNode.create(parseTableExpression(table), this.#props.withNode),
         });
     }
     /**
@@ -173,7 +168,7 @@ export class QueryCreator {
      * ```
      */
     with(name, expression) {
-        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
+        const cte = parseCommonTableExpression(name, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -187,7 +182,7 @@ export class QueryCreator {
      * See the {@link with} method for examples and more documentation.
      */
     withRecursive(name, expression) {
-        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
+        const cte = parseCommonTableExpression(name, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -202,14 +197,18 @@ export class QueryCreator {
      * This only affects the query created through the builder returned from
      * this method and doesn't modify the `db` instance.
      *
+     * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/schemas.md)
+     * for a more detailed explanation.
+     *
      * ### Examples
      *
      * ```
-     * await db.withSchema('mammals')
-     *  .selectFrom('pet')
-     *  .selectAll()
-     *  .innerJoin('public.person', 'public.person.id', 'pet.owner_id')
-     *  .execute()
+     * await db
+     *   .withSchema('mammals')
+     *   .selectFrom('pet')
+     *   .selectAll()
+     *   .innerJoin('public.person', 'public.person.id', 'pet.owner_id')
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -225,10 +224,11 @@ export class QueryCreator {
      * doesn't belong to:
      *
      * ```
-     * await db.withSchema('mammals')
-     *  .selectFrom('pet as p')
-     *  .select('p.name')
-     *  .execute()
+     * await db
+     *   .withSchema('mammals')
+     *   .selectFrom('pet as p')
+     *   .select('p.name')
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -243,130 +243,4 @@ export class QueryCreator {
             executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
         });
     }
-    /**
-     * Provides a way to pass arbitrary SQL into your query and executing completely
-     * raw queries.
-     *
-     * You can use the strings `?` and `??` in the `sql` to bind parameters such as
-     * user input to the SQL. You should never EVER concatenate untrusted user
-     * input to the SQL string to avoid injection vulnerabilities. Instead use `?`
-     * in place of a value and pass the actual value in the `parameters` list. See
-     * the examples below.
-     *
-     * You should only use `raw` when there is no other way to get the job done. This is
-     * because Kysely is not able to use type inference when you use raw SQL. For example
-     * Kysely won't be able to automatically provide you with the correct query result
-     * type. However, there are ways to manually provide types when you use `raw` in most
-     * cases. See the examples below.
-     *
-     * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
-     * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
-     *
-     * ### Examples
-     *
-     * Example of using `raw` in a select statement:
-     *
-     * ```ts
-     * const [person] = await db.selectFrom('person')
-     *   .select(db.raw<string>('concat(first_name, ' ', last_name)').as('name'))
-     *   .where('id', '=', 1)
-     *   .execute()
-     *
-     * console.log(person.name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select concat(first_name, ' ', last_name) as "name"
-     * from "person" where "id" = 1
-     * ```
-     *
-     * The above example selects computed column `name` by concatenating the first name
-     * and last name together.
-     *
-     * There are couple of things worth noticing:
-     *
-     *   1. You need to provide the output type of your SQL segment for the `raw` method
-     *     so that Kysely knows what type to give for the `name` column. In this case it's
-     *     a `string` since that's the output type of the `concat` function in SQL.
-     *
-     *   2. You need to give an alias for the selection using the `as` method so that
-     *     Kysely is able to add a column to the output type. The alias needs to be
-     *     known at compile time! If you pass a string variable whose value is not known
-     *     at compile time, there is no way for Kysely or typescript to add a column to
-     *     the output type. In this case you need to use the `castTo` method on the query
-     *     to specify a return type for the query.
-     *
-     * We could've also used a `??` placeholder to provide `first_name` and `last_name` like
-     * this:
-     *
-     * ```ts
-     * db.raw<string>('concat(??, ' ', ??)', ['first_name', 'last_name'])
-     * ```
-     *
-     * or this:
-     *
-     * ```ts
-     * db.raw<string>('concat(??, ' ', ??)', ['person.first_name', 'person.last_name'])
-     * ```
-     *
-     * But it's often cleaner to just write the column names in the SQL. Again remember to
-     * never concatenate column names or any other untrusted user input to the SQL string or you
-     * are going to create an injection vulnerability. All user input should go to the parameters
-     * array, never to the SQL string directly. But if the column names or values are trusted
-     * and known at compile time, there is no reason to use parameters.
-     *
-     * Example of using `raw` in `where`:
-     *
-     * ```ts
-     * function getPersonsOlderThan(ageLimit: number) {
-     *   return await db.selectFrom('person')
-     *     .selectAll()
-     *     .where(
-     *       db.raw('now() - birth_date'),
-     *       '>',
-     *       db.raw('interval ? year', [ageLimit.toString()])
-     *     )
-     *     .execute()
-     * }
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where now() - birth_date > interval $1 year
-     * ```
-     *
-     * The function in the above example returns people that are older than the given number of
-     * years. The number of years in this example is an untrusted user input, and therefore we use
-     * a `?` placeholder for it.
-     *
-     * Example of creating a completely raw query from scratch:
-     *
-     * ```ts
-     * const result = await db.raw<Person>('select p.* from person p').execute()
-     * const persons = result.rows
-     * ```
-     *
-     * For a raw query, you need to specify the type of the returned __row__. In
-     * this case we know the resulting items will be of type `Person` se specify that.
-     * The result of `execute()` method is always an array. In this case the type of
-     * the `persons` variable is `Person[]`.
-     *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
-     *    placeholders. `?` for values and `??` for identifiers such as column names
-     *    or `column.table` references.
-     *
-     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
-     *    the sql string.
-     */
-    raw(sql, parameters) {
-        return new RawBuilder({
-            queryId: createQueryId(),
-            executor: this.#props.executor,
-            sql,
-            parameters,
-        });
-    }
 }

package/dist/esm/query-executor/default-query-executor.d.ts

@@ -4,9 +4,11 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { RootOperationNode, QueryCompiler } from '../query-compiler/query-compiler.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutor } from './query-executor.js';
+import { DialectAdapter } from '../index-nodeless.js';
 export declare class DefaultQueryExecutor extends QueryExecutor {
     #private;
-    constructor(compiler: QueryCompiler, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    constructor(compiler: QueryCompiler, adapter: DialectAdapter, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    get adapter(): DialectAdapter;
     /**
      * Compiles the transformed query into SQL. You usually want to pass
      * the output of {@link transformQuery} into this method but you can
@@ -14,6 +16,11 @@ export declare class DefaultQueryExecutor extends QueryExecutor {
      */
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected executeQueryImpl<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    withPlugins(plugins: ReadonlyArray<KyselyPlugin>): DefaultQueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.

package/dist/esm/query-executor/default-query-executor.js

@@ -2,12 +2,17 @@
 import { QueryExecutor } from './query-executor.js';
 export class DefaultQueryExecutor extends QueryExecutor {
     #compiler;
+    #adapter;
     #connectionProvider;
-    constructor(compiler, connectionProvider, plugins = []) {
+    constructor(compiler, adapter, connectionProvider, plugins = []) {
         super(plugins);
         this.#compiler = compiler;
+        this.#adapter = adapter;
         this.#connectionProvider = connectionProvider;
     }
+    get adapter() {
+        return this.#adapter;
+    }
     compileQuery(node) {
         return this.#compiler.compileQuery(node);
     }
@@ -16,24 +21,19 @@ export class DefaultQueryExecutor extends QueryExecutor {
             return connection.executeQuery(compiledQuery);
         });
     }
+    withPlugins(plugins) {
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [...this.plugins, ...plugins]);
+    }
     withPlugin(plugin) {
-        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, [
-            ...this.plugins,
-            plugin,
-        ]);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [...this.plugins, plugin]);
     }
     withPluginAtFront(plugin) {
-        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, [
-            plugin,
-            ...this.plugins,
-        ]);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [plugin, ...this.plugins]);
     }
     withConnectionProvider(connectionProvider) {
-        return new DefaultQueryExecutor(this.#compiler, connectionProvider, [
-            ...this.plugins,
-        ]);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, connectionProvider, [...this.plugins]);
     }
     withoutPlugins() {
-        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, []);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, []);
     }
 }

package/dist/esm/query-executor/noop-query-executor.d.ts

@@ -2,12 +2,14 @@ import { QueryResult } from '../driver/database-connection.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { QueryExecutor } from './query-executor.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
 /**
  * A {@link QueryExecutor} subclass that can be used when you don't
  * have a {@link QueryCompiler}, {@link ConnectionProvider} or any
  * other needed things to actually execute queries.
  */
 export declare class NoopQueryExecutor extends QueryExecutor {
+    get adapter(): DialectAdapter;
     /**
      * Compiles the transformed query into SQL. You usually want to pass
      * the output of {@link transformQuery} into this method but you can
@@ -24,6 +26,11 @@ export declare class NoopQueryExecutor extends QueryExecutor {
      * last plugin.
      */
     withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    withPlugins(plugins: ReadonlyArray<KyselyPlugin>): NoopQueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.
@@ -34,3 +41,4 @@ export declare class NoopQueryExecutor extends QueryExecutor {
      */
     withoutPlugins(): QueryExecutor;
 }
+export declare const NOOP_QUERY_EXECUTOR: NoopQueryExecutor;

package/dist/esm/query-executor/noop-query-executor.js

@@ -6,6 +6,9 @@ import { QueryExecutor } from './query-executor.js';
  * other needed things to actually execute queries.
  */
 export class NoopQueryExecutor extends QueryExecutor {
+    get adapter() {
+        throw new Error('this query cannot be compiled to SQL');
+    }
     compileQuery() {
         throw new Error('this query cannot be compiled to SQL');
     }
@@ -18,6 +21,9 @@ export class NoopQueryExecutor extends QueryExecutor {
     withPlugin(plugin) {
         return new NoopQueryExecutor([...this.plugins, plugin]);
     }
+    withPlugins(plugins) {
+        return new NoopQueryExecutor([...this.plugins, ...plugins]);
+    }
     withPluginAtFront(plugin) {
         return new NoopQueryExecutor([plugin, ...this.plugins]);
     }
@@ -25,3 +31,4 @@ export class NoopQueryExecutor extends QueryExecutor {
         return new NoopQueryExecutor([]);
     }
 }
+export const NOOP_QUERY_EXECUTOR = new NoopQueryExecutor();

package/dist/esm/query-executor/query-executor-provider.d.ts

@@ -0,0 +1,8 @@
+import { QueryExecutor } from './query-executor.js';
+/**
+ * @internal
+ * @private
+ */
+export interface QueryExecutorProvider {
+    getExecutor(): QueryExecutor;
+}

package/dist/esm/query-executor/query-executor-provider.js

@@ -0,0 +1,2 @@
+/// <reference types="./query-executor-provider.d.ts" />
+export {};

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

@@ -4,6 +4,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { RootOperationNode } from '../query-compiler/query-compiler.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
 /**
  * This class abstracts away the details of how to compile a query into SQL
  * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
@@ -13,6 +14,7 @@ import { QueryId } from '../util/query-id.js';
 export declare abstract class QueryExecutor {
     #private;
     constructor(plugins?: KyselyPlugin[]);
+    abstract get adapter(): DialectAdapter;
     get plugins(): ReadonlyArray<KyselyPlugin>;
     /**
      * Given the query the user has built (expressed as an operation node tree)
@@ -44,6 +46,11 @@ export declare abstract class QueryExecutor {
      * last plugin.
      */
     abstract withPlugin(plugin: KyselyPlugin): QueryExecutor;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.

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

@@ -2,25 +2,57 @@ import { QueryResult } from '../driver/database-connection.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { QueryExecutor } from '../query-executor/query-executor.js';
-import { QueryId } from '../util/query-id.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
+import { QueryId } from '../util/query-id.js';
+/**
+ * An instance of this class can be used to create raw SQL snippets or queries.
+ *
+ * You shouldn't need to create `RawBuilder` instances directly. Instead you should
+ * use the {@link sql} template tag.
+ */
 export declare class RawBuilder<O = unknown> implements OperationNodeSource {
     #private;
     constructor(props: RawBuilderProps);
+    /**
+     * Returns an aliased version of the SQL expression.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * ```
+     */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
-     * This doesn't produce any SQL. This methods simply returns a copy
-     * of this `RawBuilder` with a new output type.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `RawBuilder` with a new output type.
      */
     castTo<T>(): RawBuilder<T>;
+    /**
+     * Adds a plugin for this SQL snippet.
+     */
     withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
     toOperationNode(): RawNode;
-    compile(): CompiledQuery;
-    execute(): Promise<QueryResult<O>>;
+    execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
 }
 /**
  * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
@@ -40,8 +72,7 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
     constructor(rawBuilder: RawBuilder<O>, alias: A);
 }
 export interface RawBuilderProps {
-    readonly queryId?: QueryId;
-    readonly executor?: QueryExecutor;
-    readonly sql: string;
-    readonly parameters?: ReadonlyArray<unknown>;
+    readonly queryId: QueryId;
+    readonly rawNode: RawNode;
+    readonly plugins?: ReadonlyArray<KyselyPlugin>;
 }

package/dist/esm/raw-builder/raw-builder.js

@@ -1,74 +1,84 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { parseStringReference } from '../parser/reference-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
-import { createQueryId } from '../util/query-id.js';
 import { freeze } from '../util/object-utils.js';
-import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
+import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+/**
+ * An instance of this class can be used to create raw SQL snippets or queries.
+ *
+ * You shouldn't need to create `RawBuilder` instances directly. Instead you should
+ * use the {@link sql} template tag.
+ */
 export class RawBuilder {
     #props;
     constructor(props) {
-        this.#props = freeze({
-            queryId: props.queryId ?? createQueryId(),
-            executor: props.executor ?? new NoopQueryExecutor(),
-            sql: props.sql,
-            parameters: props.parameters,
-        });
+        this.#props = freeze(props);
     }
+    /**
+     * Returns an aliased version of the SQL expression.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * ```
+     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
     /**
      * Change the output type of the raw expression.
      *
-     * This doesn't produce any SQL. This methods simply returns a copy
-     * of this `RawBuilder` with a new output type.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `RawBuilder` with a new output type.
      */
     castTo() {
-        return new RawBuilder({
-            ...this.#props,
-        });
+        return new RawBuilder({ ...this.#props });
     }
+    /**
+     * Adds a plugin for this SQL snippet.
+     */
     withPlugin(plugin) {
         return new RawBuilder({
             ...this.#props,
-            executor: this.#props.executor.withPlugin(plugin),
+            plugins: this.#props.plugins !== undefined
+                ? freeze([...this.#props.plugins, plugin])
+                : freeze([plugin]),
         });
     }
     toOperationNode() {
-        const parameterPlaceholderRegex = /(\?\??)/g;
-        const sql = this.#props.sql;
-        const parameters = this.#props.parameters ?? [];
-        const sqlFragments = [];
-        const argNodes = [];
-        let paramIdx = 0;
-        let sqlIdx = 0;
-        let match = null;
-        while ((match = parameterPlaceholderRegex.exec(sql))) {
-            const str = match[1];
-            if (paramIdx >= parameters.length) {
-                throw new Error(`value not provided for all placeholders in string ${sql}`);
-            }
-            if (match.index > 0 && sql[match.index - 1] === '\\') {
-                continue;
-            }
-            sqlFragments.push(sql.slice(sqlIdx, match.index).replace(/\\\?/g, '?'));
-            argNodes.push(parseRawArg(str, parameters[paramIdx]));
-            sqlIdx = match.index + str.length;
-            ++paramIdx;
-        }
-        sqlFragments.push(sql.slice(sqlIdx));
-        const rawNode = RawNode.create(sqlFragments, argNodes);
-        return this.#props.executor.transformQuery(rawNode, this.#props.queryId);
+        const executor = this.#props.plugins !== undefined
+            ? NOOP_QUERY_EXECUTOR.withPlugins(this.#props.plugins)
+            : NOOP_QUERY_EXECUTOR;
+        return this.#toOperationNode(executor);
     }
-    compile() {
-        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    async execute(executorProvider) {
+        const executor = this.#props.plugins !== undefined
+            ? executorProvider.getExecutor().withPlugins(this.#props.plugins)
+            : executorProvider.getExecutor();
+        return executor.executeQuery(this.#compile(executor), this.#props.queryId);
     }
-    async execute() {
-        return this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    #toOperationNode(executor) {
+        return executor.transformQuery(this.#props.rawNode, this.#props.queryId);
+    }
+    #compile(executor) {
+        return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
     }
 }
 preventAwait(RawBuilder, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
@@ -97,14 +107,3 @@ export class AliasedRawBuilder {
         this.#alias = alias;
     }
 }
-function parseRawArg(match, arg) {
-    if (isOperationNodeSource(arg)) {
-        return arg.toOperationNode();
-    }
-    else if (match === '??') {
-        return parseStringReference(arg);
-    }
-    else {
-        return ValueNode.create(arg);
-    }
-}