kysely 0.16.7 → 0.16.11

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Sami Koskimäki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -204,14 +204,24 @@ export async function down(db: Kysely<any>): Promise<void> {
 ```
 
 The `up` function is called when you update your database schema to next version and `down`
-when you go back to previous version. The only argument to the functions is an instance of
-`Kysely<any>`. It is important to use `Kysely<any>` and not `Kysely<YourDatabase>`. Migrations
-should never depend on the current code of your app because they need to work even if the app
-changes completely. Migrations need to be "frozen in time".
+when you go back to previous version. The only argument for the functions is an instance of
+`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. Migrations
+should never depend on the current code of your app because they need to work even when the app
+changes. Migrations need to be "frozen in time".
 
 The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)
 module to modify the schema. Migrations can also run normal queries to modify data.
 
+Execution order of the migrations is the alpabetical order of their names. An excellent way to name your
+migrations is to prefix them with an ISO 8601 date string. A date prefix works well in large teams
+where multiple team members may add migrations at the same time in parallel commits without knowing
+about the other migrations.
+
+You don't need to store your migrations as separate files if you don't want to. You can easily
+implement your own [MigrationProvider](https://koskimas.github.io/kysely/interfaces/MigrationProvider.html)
+and give it to the [Migrator](https://koskimas.github.io/kysely/classes/Migrator.html) class
+when you instantiate one.
+
 ### PostgreSQL migration example
 
 ```ts
@@ -295,9 +305,9 @@ const migrator = new Migrator(migratorConfig);
 await migrator.migrateToLatest(pathToMigrationsFolder)
 ```
 
-to run all migrations that have not yet been run. The migrations are executed in alphabetical
-order by their name. See the [Migrator](https://koskimas.github.io/kysely/classes/Migrator.html) 
-documentation for more info.
+to run all migrations that have not yet been run. See the
+[Migrator](https://koskimas.github.io/kysely/classes/Migrator.html)
+class's documentation for more info.
 
 Kysely doesn't have a CLI for running migrations and probably never will. This is because Kysely's
 migrations are also written in typescript. To run the migrations, you need to first build the
@@ -352,9 +362,11 @@ async function migrateToLatest() {
 migrateToLatest()
 ```
 
-The migration methods use a lock on the database level, and parallel calls are executed serially.
+The migration methods use a lock on the database level and parallel calls are executed serially.
 This means that you can safely call `migrateToLatest` and other migration methods from multiple
-server instances simultaneously and the migrations are guaranteed to only be executed once.
+server instances simultaneously and the migrations are guaranteed to only be executed once. The
+locks are also automatically released if the migration process crashes or the connection to the
+database fails.
 
 # Deno
 

package/dist/cjs/kysely.js

@@ -345,12 +345,12 @@ class ConnectionBuilder {
     async execute(callback) {
         const connection = await this.#props.driver.acquireConnection();
         const connectionProvider = new single_connection_provider_js_1.SingleConnectionProvider(connection);
-        const transaction = new Kysely({
+        const db = new Kysely({
             ...this.#props,
             executor: this.#props.executor.withConnectionProvider(connectionProvider),
         });
         try {
-            return await callback(transaction);
+            return await callback(db);
         }
         finally {
             await this.#props.driver.releaseConnection(connection);

package/dist/cjs/migration/migrator.d.ts

@@ -36,6 +36,12 @@ export interface Migration {
 export declare class Migrator {
     #private;
     constructor(props: MigratorProps);
+    /**
+     * Returns a {@link MigrationInfo} object for each migration.
+     *
+     * The returned array is sorted by migration name.
+     */
+    getMigrations(): Promise<ReadonlyArray<MigrationInfo>>;
     /**
      * Runs all migrations that have not yet been run.
      *
@@ -219,3 +225,19 @@ export interface MigrationProvider {
 export interface NoMigrations {
     readonly __noMigrations__: true;
 }
+export interface MigrationInfo {
+    /**
+     * Name of the migration.
+     */
+    name: string;
+    /**
+     * The actual migration.
+     */
+    migration: Migration;
+    /**
+     * When was the migration executed.
+     *
+     * If this is undefined, the migration hasn't been executed yet.
+     */
+    executedAt?: Date;
+}

package/dist/cjs/migration/migrator.js

@@ -32,6 +32,28 @@ class Migrator {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /**
+     * Returns a {@link MigrationInfo} object for each migration.
+     *
+     * The returned array is sorted by migration name.
+     */
+    async getMigrations() {
+        const executedMigrations = (await this.#doesTableExists(exports.MIGRATION_TABLE))
+            ? await this.#props.db
+                .selectFrom(exports.MIGRATION_TABLE)
+                .select(['name', 'timestamp'])
+                .execute()
+            : [];
+        const migrations = await this.#resolveMigrations();
+        return migrations.map(({ name, ...migration }) => {
+            const executed = executedMigrations.find((it) => it.name === name);
+            return {
+                name,
+                migration,
+                executedAt: executed ? new Date(executed.timestamp) : undefined,
+            };
+        });
+    }
     /**
      * Runs all migrations that have not yet been run.
      *
@@ -215,7 +237,7 @@ class Migrator {
             try {
                 await this.#props.db
                     .insertInto(exports.MIGRATION_LOCK_TABLE)
-                    .values({ id: exports.MIGRATION_LOCK_ID })
+                    .values({ id: exports.MIGRATION_LOCK_ID, is_locked: 0 })
                     .execute();
             }
             catch (error) {

package/dist/cjs/operation-node/delete-query-node.d.ts

@@ -5,6 +5,9 @@ import { TableExpressionNode } from './operation-node-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { LimitNode } from './limit-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -12,6 +15,8 @@ export interface DeleteQueryNode extends OperationNode {
     readonly where?: WhereNode;
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
+    readonly orderBy?: OrderByNode;
+    readonly limit?: LimitNode;
 }
 /**
  * @internal
@@ -19,4 +24,6 @@ export interface DeleteQueryNode extends OperationNode {
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItem: TableExpressionNode, withNode?: WithNode | undefined): DeleteQueryNode;
+    cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
+    cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
 }>;

package/dist/cjs/operation-node/delete-query-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteQueryNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const from_node_js_1 = require("./from-node.js");
+const order_by_node_js_1 = require("./order-by-node.js");
 /**
  * @internal
  */
@@ -17,4 +18,18 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
             ...(withNode && { with: withNode }),
         });
     },
+    cloneWithOrderByItem(deleteNode, item) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            orderBy: deleteNode.orderBy
+                ? order_by_node_js_1.OrderByNode.cloneWithItem(deleteNode.orderBy, item)
+                : order_by_node_js_1.OrderByNode.create(item),
+        });
+    },
+    cloneWithLimit(deleteNode, limit) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            limit,
+        });
+    },
 });

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

@@ -19,6 +19,7 @@ import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { Selectable } from '../util/column-type.js';
+import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -564,8 +565,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Return arbitrary expressions:
      *
      * ```ts
-     * const { raw } = db
-     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -574,7 +573,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   })
      *   .returning([
      *     'id as id',
-     *     raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     db.raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
      *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()
@@ -587,6 +586,60 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * that support `returning` such as PostgreSQL.
      */
     returningAll(): DeleteQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    /**
+     * Adds an `order by` clause to the query.
+     *
+     * `orderBy` calls are additive. To order by multiple columns, call `orderBy`
+     * multiple times.
+     *
+     * The first argument is the expression to order by and the second is the
+     * order (`asc` or `desc`).
+     *
+     * An `order by` clause in a delete query is only supported by some dialects
+     * like MySQL.
+     *
+     * See {@link SelectQueryBuilder.orderBy} for more examples.
+     *
+     * ### Examples
+     *
+     * Delete 5 oldest items in a table:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .orderBy('created_at')
+     *   .limit(5)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `pet`
+     * order by `created_at`
+     * limit ?
+     * ```
+     */
+    orderBy(orderBy: OrderByExpression<DB, TB, O>, direction?: OrderByDirectionExpression): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Adds a limit clause to the query.
+     *
+     * A limit clause in a delete query is only supported by some dialects
+     * like MySQL.
+     *
+     * ### Examples
+     *
+     * Delete 5 oldest items in a table:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .orderBy('created_at')
+     *   .limit(5)
+     *   .execute()
+     * ```
+     */
+    limit(limit: number): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *

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

@@ -9,6 +9,9 @@ const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const delete_result_js_1 = require("./delete-result.js");
+const delete_query_node_js_1 = require("../operation-node/delete-query-node.js");
+const limit_node_js_1 = require("../operation-node/limit-node.js");
+const order_by_parser_js_1 = require("../parser/order-by-parser.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -98,6 +101,70 @@ class DeleteQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),
         });
     }
+    /**
+     * Adds an `order by` clause to the query.
+     *
+     * `orderBy` calls are additive. To order by multiple columns, call `orderBy`
+     * multiple times.
+     *
+     * The first argument is the expression to order by and the second is the
+     * order (`asc` or `desc`).
+     *
+     * An `order by` clause in a delete query is only supported by some dialects
+     * like MySQL.
+     *
+     * See {@link SelectQueryBuilder.orderBy} for more examples.
+     *
+     * ### Examples
+     *
+     * Delete 5 oldest items in a table:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .orderBy('created_at')
+     *   .limit(5)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `pet`
+     * order by `created_at`
+     * limit ?
+     * ```
+     */
+    orderBy(orderBy, direction) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, (0, order_by_parser_js_1.parseOrderBy)(this.#props.parseContext, orderBy, direction)),
+        });
+    }
+    /**
+     * Adds a limit clause to the query.
+     *
+     * A limit clause in a delete query is only supported by some dialects
+     * like MySQL.
+     *
+     * ### Examples
+     *
+     * Delete 5 oldest items in a table:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('pet')
+     *   .orderBy('created_at')
+     *   .limit(5)
+     *   .execute()
+     * ```
+     */
+    limit(limit) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create(limit)),
+        });
+    }
     /**
      * Simply calls the given function passing `this` as the only argument.
      *

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

@@ -423,8 +423,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * Return arbitrary expressions:
      *
      * ```ts
-     * const { raw } = db
-     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -433,7 +431,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   })
      *   .returning([
      *     'id as id',
-     *     raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     db.raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
      *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()

package/dist/cjs/query-builder/returning-interface.d.ts

@@ -45,8 +45,6 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      * Return arbitrary expressions:
      *
      * ```ts
-     * const { raw } = db
-     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -55,7 +53,7 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      *   })
      *   .returning([
      *     'id as id',
-     *     raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     db.raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
      *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()

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

@@ -456,7 +456,10 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * same as calling `select(['id', 'first_name']).
      *
      * To select all columns of the query or specific tables see the
-     * {@link SelectQueryBuilder.selectAll | selectAll} method.
+     * {@link selectAll} method.
+     *
+     * See the {@link if} method if you are looking for a way to add selections
+     * based on a runtime condition.
      *
      * ### Examples
      *
@@ -971,14 +974,12 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * `groupBy` also accepts an array:
      *
      * ```ts
-     * const { raw } = db
-     *
      * await db
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     raw('max(id)').as('max_id')
+     *     db.raw('max(id)').as('max_id')
      *   ])
      *   .groupBy([
      *     'first_name',
@@ -999,17 +1000,15 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * raw expressions:
      *
      * ```ts
-     * const { raw } = db
-     *
      * await db
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     raw('max(id)').as('max_id')
+     *     db.raw('max(id)').as('max_id')
      *   ])
      *   .groupBy([
-     *     raw('concat(first_name, last_name)'),
+     *     db.raw('concat(first_name, last_name)'),
      *     (qb) => qb.selectFrom('pet').select('id').limit(1)
      *   ])
      *   .execute()

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

@@ -651,8 +651,6 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Return arbitrary expressions:
      *
      * ```ts
-     * const { raw } = db
-     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -661,7 +659,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   })
      *   .returning([
      *     'id as id',
-     *     raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     db.raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
      *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -29,9 +29,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitSelectQuery(node) {
         const wrapInParens = this.parentNode !== undefined &&
+            !insert_query_node_js_1.InsertQueryNode.is(this.parentNode) &&
             !create_view_node_js_1.CreateViewNode.is(this.parentNode) &&
-            !union_node_js_1.UnionNode.is(this.parentNode) &&
-            !insert_query_node_js_1.InsertQueryNode.is(this.parentNode);
+            !union_node_js_1.UnionNode.is(this.parentNode);
         if (wrapInParens) {
             this.append('(');
         }
@@ -190,6 +190,14 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.where);
         }
+        if (node.orderBy) {
+            this.append(' ');
+            this.visitNode(node.orderBy);
+        }
+        if (node.limit) {
+            this.append(' ');
+            this.visitNode(node.limit);
+        }
         if (node.returning) {
             this.append(' ');
             this.visitNode(node.returning);
@@ -285,12 +293,13 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.visitNode(node.on);
     }
     visitRaw(node) {
-        node.sqlFragments.forEach((sql, i) => {
-            this.append(sql);
-            if (node.params.length > i) {
-                this.visitNode(node.params[i]);
+        const { sqlFragments, params } = node;
+        for (let i = 0; i < sqlFragments.length; ++i) {
+            this.append(sqlFragments[i]);
+            if (params.length > i) {
+                this.visitNode(params[i]);
             }
-        });
+        }
     }
     visitOperator(node) {
         this.append(node.operator);

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

@@ -258,14 +258,18 @@ export declare class QueryCreator<DB> {
      * 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):
@@ -281,10 +285,11 @@ export declare class QueryCreator<DB> {
      * 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):

package/dist/cjs/query-creator.js

@@ -204,14 +204,18 @@ 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):
@@ -227,10 +231,11 @@ 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):

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>;
 }

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

@@ -7,11 +7,18 @@ const raw_node_js_1 = require("../operation-node/raw-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
 class RawBuilder {
     #props;
     constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)(props);
+        this.#props = (0, object_utils_js_1.freeze)({
+            queryId: props.queryId ?? (0, query_id_js_1.createQueryId)(),
+            executor: props.executor ?? new noop_query_executor_js_1.NoopQueryExecutor(),
+            sql: props.sql,
+            parameters: props.parameters,
+        });
     }
     as(alias) {
         return new AliasedRawBuilder(this, alias);