kysely 0.16.4 → 0.16.8

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -3,12 +3,13 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { InsertObject } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { SingleResultType } from '../util/type-utils.js';
+import { MergePartial, SingleResultType } from '../util/type-utils.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
@@ -448,24 +449,62 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.onConflict((oc) => oc.column('something').doNothing())
-     *     } else {
-     *       return qb.onConflict((oc) => oc.column('something_else').doNothing())
-     *     }
-     *   })
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.updateTable('person')
+     *   .set(values)
+     *   .call(log)
      *   .execute()
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function insertPerson(values: InsertablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .insertInto('person')
+     *     .values(values)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `insertPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): InsertQueryBuilder<DB, TB, O2 extends InsertResult ? InsertResult : O extends InsertResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
@@ -473,6 +512,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * don't support your use case.
      */
     castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): InsertQueryBuilder<DB, TB, O>;
     toOperationNode(): InsertQueryNode;
     compile(): CompiledQuery;

package/dist/cjs/query-builder/insert-query-builder.js

@@ -317,26 +317,71 @@ class InsertQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.onConflict((oc) => oc.column('something').doNothing())
-     *     } else {
-     *       return qb.onConflict((oc) => oc.column('something_else').doNothing())
-     *     }
-     *   })
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.updateTable('person')
+     *   .set(values)
+     *   .call(log)
      *   .execute()
      * ```
      */
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function insertPerson(values: InsertablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .insertInto('person')
+     *     .values(values)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `insertPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new InsertQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Change the output type of the query.
      *
@@ -346,6 +391,9 @@ class InsertQueryBuilder {
     castTo() {
         return new InsertQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new InsertQueryBuilder({
             ...this.#props,

package/dist/cjs/query-builder/select-query-builder.d.ts

@@ -7,7 +7,7 @@ import { SelectExpression, QueryBuilderWithSelection, SelectAllQueryBuilder } fr
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper, HavingGrouper } from '../parser/filter-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -1116,27 +1116,15 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
-     *   .execute()
-     * ```
-     *
      * The next example uses a helper funtion `log` to log a query:
      *
      * ```ts
-     * function log<T extends AnyQueryBuilder>(qb: T): T {
+     * function log<T extends Compilable>(qb: T): T {
      *   console.log(qb.compile())
      *   return qb
      * }
@@ -1148,6 +1136,57 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `select` or `selectAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * Also see [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/conditional-selects.md)
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function getPerson(id: number, withLastName: boolean) {
+     *   return await db
+     *     .selectFrom('person')
+     *     .select(['id', 'first_name'])
+     *     .if(withLastName, (qb) => qb.select('last_name'))
+     *     .where('id', '=', id)
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `getPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     *
+     * You can also call any other methods inside the callback:
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * db.selectFrom('person')
+     *   .select('person.id')
+     *   .if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
+     *   .if(filterByPetCount, (qb) => qb
+     *     .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *     .having(count('pet.id'), '>', petCountLimit)
+     *     .groupBy('person.id')
+     *   )
+     * ```
+     */
+    if<O2 extends O>(condition: boolean, func: (qb: this) => SelectQueryBuilder<DB, TB, O2>): SelectQueryBuilder<DB, TB, MergePartial<O, O2>>;
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -1173,6 +1212,9 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): SelectQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O>;
     toOperationNode(): SelectQueryNode;
     compile(): CompiledQuery;

package/dist/cjs/query-builder/select-query-builder.js

@@ -427,27 +427,15 @@ class SelectQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
-     *   .execute()
-     * ```
-     *
      * The next example uses a helper funtion `log` to log a query:
      *
      * ```ts
-     * function log<T extends AnyQueryBuilder>(qb: T): T {
+     * function log<T extends Compilable>(qb: T): T {
      *   console.log(qb.compile())
      *   return qb
      * }
@@ -461,6 +449,64 @@ class SelectQueryBuilder {
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `select` or `selectAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * Also see [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/conditional-selects.md)
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function getPerson(id: number, withLastName: boolean) {
+     *   return await db
+     *     .selectFrom('person')
+     *     .select(['id', 'first_name'])
+     *     .if(withLastName, (qb) => qb.select('last_name'))
+     *     .where('id', '=', id)
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `getPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     *
+     * You can also call any other methods inside the callback:
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * db.selectFrom('person')
+     *   .select('person.id')
+     *   .if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
+     *   .if(filterByPetCount, (qb) => qb
+     *     .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *     .having(count('pet.id'), '>', petCountLimit)
+     *     .groupBy('person.id')
+     *   )
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new SelectQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -490,6 +536,9 @@ class SelectQueryBuilder {
     castTo() {
         return new SelectQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new SelectQueryBuilder({
             ...this.#props,

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -6,13 +6,14 @@ import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { UpdateResult } from './update-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { JoinInterface } from './join-interface.js';
@@ -676,24 +677,63 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.updateTable('person')
      *   .set(values)
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .updateTable('person')
+     *     .set(updates)
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `updatePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, TB, O2>): UpdateQueryBuilder<DB, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
@@ -701,6 +741,9 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): UpdateQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, TB, O>;
     toOperationNode(): UpdateQueryNode;
     compile(): CompiledQuery;

package/dist/cjs/query-builder/update-query-builder.js

@@ -194,26 +194,72 @@ class UpdateQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.updateTable('person')
      *   .set(values)
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .updateTable('person')
+     *     .set(updates)
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `updatePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new UpdateQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Change the output type of the query.
      *
@@ -223,6 +269,9 @@ class UpdateQueryBuilder {
     castTo() {
         return new UpdateQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new UpdateQueryBuilder({
             ...this.#props,

package/dist/cjs/query-compiler/default-query-compiler.d.ts

@@ -44,7 +44,6 @@ import { ValueNode } from '../operation-node/value-node.js';
 import { WhereNode } from '../operation-node/where-node.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { WithNode } from '../operation-node/with-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { CompiledQuery } from './compiled-query.js';
 import { RootOperationNode, QueryCompiler } from './query-compiler.js';
 import { HavingNode } from '../operation-node/having-node.js';
@@ -150,5 +149,5 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
     protected addParameter(parameter: unknown): void;
-    protected appendImmediateValue(value: PrimitiveValue): void;
+    protected appendImmediateValue(value: unknown): void;
 }

package/dist/cjs/query-creator.d.ts

@@ -162,7 +162,7 @@ export declare class QueryCreator<DB> {
     /**
      * Creates a delete query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
@@ -182,7 +182,7 @@ export declare class QueryCreator<DB> {
     /**
      * Creates an update query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
      * a where clause for the update operation.
      *
      * See the {@link UpdateQueryBuilder.set} method for examples on how to

package/dist/cjs/query-creator.js

@@ -78,7 +78,7 @@ class QueryCreator {
     /**
      * Creates a delete query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
      * a where clause for the delete operation.
      *
      * The return value of the query is an instance of {@link DeleteResult}.
@@ -105,7 +105,7 @@ class QueryCreator {
     /**
      * Creates an update query.
      *
-     * See the {@link WhereInterface.where} method for examples on how to specify
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
      * a where clause for the update operation.
      *
      * See the {@link UpdateQueryBuilder.set} method for examples on how to

package/dist/cjs/query-executor/query-executor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExecutor = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
 /**
  * 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}
@@ -10,8 +11,8 @@ const object_utils_js_1 = require("../util/object-utils.js");
  */
 class QueryExecutor {
     #plugins;
-    constructor(plugins = []) {
-        this.#plugins = (0, object_utils_js_1.freeze)([...plugins]);
+    constructor(plugins) {
+        this.#plugins = plugins ?? NO_PLUGINS;
     }
     get plugins() {
         return this.#plugins;

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

@@ -40,8 +40,8 @@ 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 queryId?: QueryId;
+    readonly executor?: QueryExecutor;
     readonly sql: string;
     readonly parameters?: ReadonlyArray<unknown>;
 }