kysely 0.16.7 → 0.16.11

package/dist/cjs/schema/alter-table-builder.js

@@ -9,7 +9,6 @@ const data_type_node_js_1 = require("../operation-node/data-type-node.js");
 const drop_column_node_js_1 = require("../operation-node/drop-column-node.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const rename_column_node_js_1 = require("../operation-node/rename-column-node.js");
-const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const column_definition_builder_js_1 = require("./column-definition-builder.js");
@@ -22,6 +21,7 @@ const check_constraint_node_js_1 = require("../operation-node/check-constraint-n
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
 const default_value_parser_js_1 = require("../parser/default-value-parser.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -34,7 +34,7 @@ class AlterTableBuilder {
         return new AlterTableExecutor({
             ...this.#props,
             alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
-                renameTo: table_node_js_1.TableNode.create(newTableName),
+                renameTo: (0, table_parser_js_1.parseTable)(newTableName),
             }),
         });
     }
@@ -104,7 +104,7 @@ class AlterTableBuilder {
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
         return new AlterTableAddForeignKeyConstraintBuilder({
             ...this.#props,
-            constraintBuilder: new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), table_node_js_1.TableNode.create(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)),
+            constraintBuilder: new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), (0, table_parser_js_1.parseTable)(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)),
         });
     }
 }

package/dist/cjs/schema/create-table-builder.js

@@ -8,12 +8,12 @@ const column_definition_builder_js_1 = require("./column-definition-builder.js")
 const object_utils_js_1 = require("../util/object-utils.js");
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
-const table_node_js_1 = require("../operation-node/table-node.js");
 const foreign_key_constraint_builder_js_1 = require("./foreign-key-constraint-builder.js");
 const data_type_parser_js_1 = require("../parser/data-type-parser.js");
 const primary_constraint_node_js_1 = require("../operation-node/primary-constraint-node.js");
 const unique_constraint_node_js_1 = require("../operation-node/unique-constraint-node.js");
 const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 /**
  * This builder can be used to create a `create table` query.
  */
@@ -195,7 +195,7 @@ class CreateTableBuilder {
      * ```
      */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = object_utils_js_1.noop) {
-        const builder = build(new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), table_node_js_1.TableNode.create(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)));
+        const builder = build(new foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), (0, table_parser_js_1.parseTable)(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName)));
         return new CreateTableBuilder({
             ...this.#props,
             createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, builder.toOperationNode()),

package/dist/esm/kysely.js

@@ -340,12 +340,12 @@ export class ConnectionBuilder {
     async execute(callback) {
         const connection = await this.#props.driver.acquireConnection();
         const connectionProvider = new 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/esm/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/esm/migration/migrator.js

@@ -30,6 +30,28 @@ export class Migrator {
     constructor(props) {
         this.#props = 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(MIGRATION_TABLE))
+            ? await this.#props.db
+                .selectFrom(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.
      *
@@ -213,7 +235,7 @@ export class Migrator {
             try {
                 await this.#props.db
                     .insertInto(MIGRATION_LOCK_TABLE)
-                    .values({ id: MIGRATION_LOCK_ID })
+                    .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
                     .execute();
             }
             catch (error) {

package/dist/esm/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/esm/operation-node/delete-query-node.js

@@ -1,6 +1,7 @@
 /// <reference types="./delete-query-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { FromNode } from './from-node.js';
+import { OrderByNode } from './order-by-node.js';
 /**
  * @internal
  */
@@ -15,4 +16,18 @@ export const DeleteQueryNode = freeze({
             ...(withNode && { with: withNode }),
         });
     },
+    cloneWithOrderByItem(deleteNode, item) {
+        return freeze({
+            ...deleteNode,
+            orderBy: deleteNode.orderBy
+                ? OrderByNode.cloneWithItem(deleteNode.orderBy, item)
+                : OrderByNode.create(item),
+        });
+    },
+    cloneWithLimit(deleteNode, limit) {
+        return freeze({
+            ...deleteNode,
+            limit,
+        });
+    },
 });

package/dist/esm/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/esm/query-builder/delete-query-builder.js

@@ -7,6 +7,9 @@ import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { NoResultError } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
+import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
+import { LimitNode } from '../operation-node/limit-node.js';
+import { parseOrderBy, } from '../parser/order-by-parser.js';
 export class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -96,6 +99,70 @@ export class DeleteQueryBuilder {
             queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, 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: DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, 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: DeleteQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(limit)),
+        });
+    }
     /**
      * Simply calls the given function passing `this` as the only argument.
      *

package/dist/esm/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/esm/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/esm/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/esm/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/esm/query-compiler/default-query-compiler.js

@@ -27,9 +27,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitSelectQuery(node) {
         const wrapInParens = this.parentNode !== undefined &&
+            !InsertQueryNode.is(this.parentNode) &&
             !CreateViewNode.is(this.parentNode) &&
-            !UnionNode.is(this.parentNode) &&
-            !InsertQueryNode.is(this.parentNode);
+            !UnionNode.is(this.parentNode);
         if (wrapInParens) {
             this.append('(');
         }
@@ -188,6 +188,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             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);
@@ -283,12 +291,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         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/esm/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/esm/query-creator.js

@@ -202,14 +202,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 +229,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):

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

@@ -1,5 +1,6 @@
 /// <reference types="./query-executor.d.ts" />
 import { freeze } from '../util/object-utils.js';
+const NO_PLUGINS = 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}
@@ -8,8 +9,8 @@ import { freeze } from '../util/object-utils.js';
  */
 export class QueryExecutor {
     #plugins;
-    constructor(plugins = []) {
-        this.#plugins = freeze([...plugins]);
+    constructor(plugins) {
+        this.#plugins = plugins ?? NO_PLUGINS;
     }
     get plugins() {
         return this.#plugins;

package/dist/esm/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/esm/raw-builder/raw-builder.js

@@ -5,11 +5,18 @@ 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';
 export class RawBuilder {
     #props;
     constructor(props) {
-        this.#props = freeze(props);
+        this.#props = freeze({
+            queryId: props.queryId ?? createQueryId(),
+            executor: props.executor ?? new NoopQueryExecutor(),
+            sql: props.sql,
+            parameters: props.parameters,
+        });
     }
     as(alias) {
         return new AliasedRawBuilder(this, alias);