kysely 0.11.3 → 0.12.2

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

@@ -1,3 +1,4 @@
+import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
@@ -24,9 +25,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         return this.#sql;
     }
     visitSelectQuery(node) {
-        const wrapInParens = this.nodeStack.length !== 1 &&
+        const wrapInParens = this.parentNode !== undefined &&
             !CreateViewNode.is(this.parentNode) &&
-            !UnionNode.is(this.parentNode);
+            !UnionNode.is(this.parentNode) &&
+            !InsertQueryNode.is(this.parentNode);
         if (wrapInParens) {
             this.append('(');
         }
@@ -143,8 +145,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(')');
         }
         if (node.values) {
-            this.append(' values ');
-            this.compileList(node.values);
+            this.append(' ');
+            this.visitNode(node.values);
         }
         if (node.onConflict) {
             this.append(' ');
@@ -162,6 +164,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(')');
         }
     }
+    visitValues(node) {
+        this.append('values ');
+        this.compileList(node.values);
+    }
     visitDeleteQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
         if (isSubQuery) {
@@ -294,7 +300,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.table);
     }
     visitCreateTable(node) {
-        this.append('create table ');
+        this.append('create ');
+        if (node.temporary) {
+            this.append('temporary ');
+        }
+        this.append('table ');
         if (node.ifNotExists) {
             this.append('if not exists ');
         }
@@ -302,6 +312,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(' (');
         this.compileList([...node.columns, ...(node.constraints ?? [])]);
         this.append(')');
+        if (node.onCommit) {
+            this.append(' on commit ');
+            this.append(node.onCommit);
+        }
     }
     visitColumnDefinition(node) {
         this.visitNode(node.column);
@@ -556,6 +570,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitWith(node) {
         this.append('with ');
+        if (node.recursive) {
+            this.append('recursive ');
+        }
         this.compileList(node.expressions);
     }
     visitCommonTableExpression(node) {
@@ -563,6 +580,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(' as ');
         this.visitNode(node.expression);
     }
+    visitCommonTableExpressionName(node) {
+        this.visitNode(node.table);
+        if (node.columns) {
+            this.append('(');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+    }
     visitAlterTable(node) {
         this.append('alter table ');
         this.visitNode(node.table);
@@ -664,6 +689,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.materialized) {
             this.append('materialized ');
         }
+        if (node.temporary) {
+            this.append('temporary ');
+        }
         this.append('view ');
         if (node.ifNotExists) {
             this.append('if not exists ');

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

@@ -1,8 +1,11 @@
-import { QueryBuilder } from './query-builder/query-builder.js';
-import { QueryBuilderWithTable, TableExpression, TableReference } from './parser/table-parser.js';
+import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
+import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
+import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
+import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
+import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
-import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
+import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { ParseContext } from './parser/parse-context.js';
 import { InsertResult } from './query-builder/insert-result.js';
@@ -16,7 +19,8 @@ export declare class QueryCreator<DB> {
      *
      * The tables passed to this method are built as the query's `from` clause.
      *
-     * @example
+     * ### Examples
+     *
      * Create a select query for one table:
      *
      * ```ts
@@ -29,12 +33,11 @@ export declare class QueryCreator<DB> {
      * select * from "person"
      * ```
      *
-     * @example
      * Create a select query for one table with an alias:
      *
      * ```ts
      * const persons = await db.selectFrom('person as p')
-     *   .select(['p.id', 'p.first_name'])
+     *   .select(['p.id', 'first_name'])
      *   .execute()
      *
      * console.log(persons[0].id)
@@ -43,15 +46,14 @@ export declare class QueryCreator<DB> {
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select "p"."id", "p"."first_name" from "person" as "p"
+     * select "p"."id", "first_name" from "person" as "p"
      * ```
      *
-     * @example
      * Create a select query from a subquery:
      *
      * ```ts
      * const persons = await db.selectFrom(
-     *     db.selectFrom('person').select('person.id as identifier').as('p')
+     *     (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
      *   )
      *   .select('p.identifier')
      *   .execute()
@@ -68,12 +70,11 @@ export declare class QueryCreator<DB> {
      * ) as p
      * ```
      *
-     * @example
      * Create a select query from raw sql:
      *
      * ```ts
      * const items = await db.selectFrom(
-     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
+     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
      *   )
      *   .select('q.one')
      *   .execute()
@@ -94,7 +95,6 @@ export declare class QueryCreator<DB> {
      * raw segment / query so that Kysely can figure out what columns are
      * available for the query.
      *
-     * @example
      * The `selectFrom` method also accepts an array for multiple tables. All
      * the above examples can also be used in an array.
      *
@@ -102,7 +102,7 @@ export declare class QueryCreator<DB> {
      * const items = await db.selectFrom([
      *     'person as p',
      *     db.selectFrom('pet').select('pet.species').as('a'),
-     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
+     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
      *   ])
      *   .select(['p.id', 'a.species', 'q.one'])
      *   .execute()
@@ -118,20 +118,21 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<F extends TableExpression<DB, keyof DB>>(from: F[]): QueryBuilderWithTable<DB, never, {}, F>;
-    selectFrom<F extends TableExpression<DB, keyof DB>>(from: F): QueryBuilderWithTable<DB, never, {}, F>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
-     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
      * the inserted row if the db returned one.
      *
-     * See the {@link QueryBuilder.values | values} method for more info and examples. Also see
-     * the {@link QueryBuilder.returning | returning} method for a way to return columns
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples. Also see
+     * the {@link ReturningInterface.returning | returning} method for a way to return columns
      * on supported databases like PostgreSQL.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .insertInto('person')
@@ -145,11 +146,10 @@ export declare class QueryCreator<DB> {
      * console.log(result.insertId)
      * ```
      *
-     * @example
      * Some databases like PostgreSQL support the `returning` method:
      *
      * ```ts
-     * const { id } = await db
+     * const { id } = await db
      *   .insertInto('person')
      *   .values({
      *     id: db.generated,
@@ -160,16 +160,17 @@ export declare class QueryCreator<DB> {
      *   .executeTakeFirst()
      * ```
      */
-    insertInto<T extends keyof DB & string>(table: T): QueryBuilder<DB, T, InsertResult>;
+    insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
      * Creates a delete query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.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}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
@@ -179,19 +180,20 @@ export declare class QueryCreator<DB> {
      * console.log(result.numDeletedRows)
      * ```
      */
-    deleteFrom<TR extends TableReference<DB>>(table: TR): QueryBuilderWithTable<DB, never, DeleteResult, TR>;
+    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.where} method for examples on how to specify
      * a where clause for the update operation.
      *
-     * See the {@link QueryBuilder.set} method for examples on how to
+     * See the {@link UpdateQueryBuilder.set} method for examples on how to
      * specify the updates.
      *
      * The return value of the query is an {@link UpdateResult}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .updateTable('person')
@@ -202,11 +204,12 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): QueryBuilderWithTable<DB, never, UpdateResult, TR>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
+     *
+     * ### Examples
      *
-     * @example
      * ```ts
      * await db
      *   .with('jennifers', (db) => db
@@ -224,8 +227,32 @@ export declare class QueryCreator<DB> {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The CTE name can optionally specify column names in addition to
+     * a name. In that case Kysely requires the expression to retun
+     * rows with the same columns.
+     *
+     * ```ts
+     * await db
+     *   .with('jennifers(id, age)', (db) => db
+     *     .selectFrom('person')
+     *     .where('first_name', '=', 'Jennifer')
+     *     // This is ok since we return columns with the same
+     *     // names as specified by `jennifers(id, age)`.
+     *     .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
-    with<N extends string, E extends CommonTableExpression<DB>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    with<N extends string, E extends CommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    /**
+     * Creates a recursive `with` query (Common Table Expression).
+     *
+     * See the {@link with} method for examples and more documentation.
+     */
+    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.
@@ -233,7 +260,8 @@ 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.
      *
-     * @example
+     * ### Examples
+     *
      * ```
      * await db.withSchema('mammals')
      *  .selectFrom('pet')
@@ -250,7 +278,6 @@ export declare class QueryCreator<DB> {
      * on "public"."person"."id" = "mammals"."pet"."owner_id"
      * ```
      *
-     * @example
      * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
@@ -288,14 +315,8 @@ export declare class QueryCreator<DB> {
      * 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.
      *
-     * @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.
+     * ### Examples
      *
-     * @example
      * Example of using `raw` in a select statement:
      *
      * ```ts
@@ -349,7 +370,6 @@ export declare class QueryCreator<DB> {
      * 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
      * Example of using `raw` in `where`:
      *
      * ```ts
@@ -375,7 +395,6 @@ export declare class QueryCreator<DB> {
      * years. The number of years in this example is an untrusted user input, and therefore we use
      * a `?` placeholder for it.
      *
-     * @example
      * Example of creating a completely raw query from scratch:
      *
      * ```ts
@@ -387,6 +406,13 @@ export declare class QueryCreator<DB> {
      * 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<T = unknown>(sql: string, parameters?: any[]): RawBuilder<T>;
 }

package/dist/esm/query-creator.js

@@ -1,4 +1,7 @@
-import { QueryBuilder } from './query-builder/query-builder.js';
+import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
+import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
+import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
+import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
 import { DeleteQueryNode } from './operation-node/delete-query-node.js';
 import { InsertQueryNode } from './operation-node/insert-query-node.js';
 import { SelectQueryNode } from './operation-node/select-query-node.js';
@@ -16,7 +19,7 @@ export class QueryCreator {
         this.#props = freeze(props);
     }
     selectFrom(from) {
-        return new QueryBuilder({
+        return new SelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -27,14 +30,15 @@ export class QueryCreator {
      * Creates an insert query.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
-     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
      * the inserted row if the db returned one.
      *
-     * See the {@link QueryBuilder.values | values} method for more info and examples. Also see
-     * the {@link QueryBuilder.returning | returning} method for a way to return columns
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples. Also see
+     * the {@link ReturningInterface.returning | returning} method for a way to return columns
      * on supported databases like PostgreSQL.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .insertInto('person')
@@ -48,11 +52,10 @@ export class QueryCreator {
      * console.log(result.insertId)
      * ```
      *
-     * @example
      * Some databases like PostgreSQL support the `returning` method:
      *
      * ```ts
-     * const { id } = await db
+     * const { id } = await db
      *   .insertInto('person')
      *   .values({
      *     id: db.generated,
@@ -64,7 +67,7 @@ export class QueryCreator {
      * ```
      */
     insertInto(table) {
-        return new QueryBuilder({
+        return new InsertQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -74,12 +77,13 @@ export class QueryCreator {
     /**
      * Creates a delete query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.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}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
@@ -90,7 +94,7 @@ export class QueryCreator {
      * ```
      */
     deleteFrom(table) {
-        return new QueryBuilder({
+        return new DeleteQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -100,15 +104,16 @@ export class QueryCreator {
     /**
      * Creates an update query.
      *
-     * See the {@link QueryBuilder.where} method for examples on how to specify
+     * See the {@link WhereInterface.where} method for examples on how to specify
      * a where clause for the update operation.
      *
-     * See the {@link QueryBuilder.set} method for examples on how to
+     * See the {@link UpdateQueryBuilder.set} method for examples on how to
      * specify the updates.
      *
      * The return value of the query is an {@link UpdateResult}.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const result = await db
      *   .updateTable('person')
@@ -120,7 +125,7 @@ export class QueryCreator {
      * ```
      */
     updateTable(table) {
-        return new QueryBuilder({
+        return new UpdateQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,
@@ -128,9 +133,10 @@ export class QueryCreator {
         });
     }
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
+     *
+     * ### Examples
      *
-     * @example
      * ```ts
      * await db
      *   .with('jennifers', (db) => db
@@ -148,6 +154,24 @@ export class QueryCreator {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The CTE name can optionally specify column names in addition to
+     * a name. In that case Kysely requires the expression to retun
+     * rows with the same columns.
+     *
+     * ```ts
+     * await db
+     *   .with('jennifers(id, age)', (db) => db
+     *     .selectFrom('person')
+     *     .where('first_name', '=', 'Jennifer')
+     *     // This is ok since we return columns with the same
+     *     // names as specified by `jennifers(id, age)`.
+     *     .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
     with(name, expression) {
         const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
@@ -158,6 +182,20 @@ export class QueryCreator {
                 : WithNode.create(cte),
         });
     }
+    /**
+     * Creates a recursive `with` query (Common Table Expression).
+     *
+     * See the {@link with} method for examples and more documentation.
+     */
+    withRecursive(name, expression) {
+        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
+        return new QueryCreator({
+            ...this.#props,
+            withNode: this.#props.withNode
+                ? WithNode.cloneWithExpression(this.#props.withNode, cte)
+                : WithNode.create(cte, { recursive: true }),
+        });
+    }
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.
@@ -165,7 +203,8 @@ export class QueryCreator {
      * This only affects the query created through the builder returned from
      * this method and doesn't modify the `db` instance.
      *
-     * @example
+     * ### Examples
+     *
      * ```
      * await db.withSchema('mammals')
      *  .selectFrom('pet')
@@ -182,7 +221,6 @@ export class QueryCreator {
      * on "public"."person"."id" = "mammals"."pet"."owner_id"
      * ```
      *
-     * @example
      * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
@@ -225,14 +263,8 @@ export class QueryCreator {
      * 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.
      *
-     * @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.
+     * ### Examples
      *
-     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
-     *    the sql string.
-     *
-     * @example
      * Example of using `raw` in a select statement:
      *
      * ```ts
@@ -286,7 +318,6 @@ export class QueryCreator {
      * 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
      * Example of using `raw` in `where`:
      *
      * ```ts
@@ -312,7 +343,6 @@ export class QueryCreator {
      * years. The number of years in this example is an untrusted user input, and therefore we use
      * a `?` placeholder for it.
      *
-     * @example
      * Example of creating a completely raw query from scratch:
      *
      * ```ts
@@ -324,6 +354,13 @@ export class QueryCreator {
      * 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({

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

@@ -7,10 +7,29 @@ import { QueryExecutor } from './query-executor.js';
 export declare class DefaultQueryExecutor extends QueryExecutor {
     #private;
     constructor(compiler: QueryCompiler, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected executeQueryImpl<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): DefaultQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): DefaultQueryExecutor;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

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

@@ -8,10 +8,29 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
  * other needed things to actually execute queries.
  */
 export declare class NoopQueryExecutor extends QueryExecutor {
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(): CompiledQuery;
     protected executeQueryImpl<R>(): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(): QueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

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

@@ -6,7 +6,7 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.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 QueryBuilder}
+ * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */