kysely 0.17.1 → 0.18.0

package/README.md

@@ -1,3 +1,5 @@
+[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
+
 [![Discord](https://img.shields.io/discord/890118421587578920)](https://discord.gg/C9aJ49mCra)
 [![Tests](https://github.com/koskimas/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/koskimas/kysely)
 

package/dist/cjs/dialect/mysql/mysql-dialect-config.d.ts

@@ -162,6 +162,25 @@ export interface MysqlDialectConfig {
      * If keep-alive is enabled users can supply an initial delay.
      */
     keepAliveInitialDelay?: number;
+    charsetNumber?: number;
+    compress?: boolean;
+    authSwitchHandler?: (data: any, callback: () => void) => any;
+    connectAttributes?: {
+        [param: string]: any;
+    };
+    decimalNumbers?: boolean;
+    isServer?: boolean;
+    maxPreparedStatements?: number;
+    namedPlaceholders?: boolean;
+    nestTables?: boolean | string;
+    passwordSha1?: string;
+    pool?: any;
+    stream?: any;
+    uri?: string;
+    Promise?: any;
+    authPlugins?: {
+        [key: string]: any;
+    };
     /**
      * Called once for each created connection.
      *

package/dist/cjs/driver/default-connection-provider.d.ts

@@ -8,5 +8,5 @@ export declare class DefaultConnectionProvider implements ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    provideConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/driver/default-connection-provider.js

@@ -6,10 +6,10 @@ class DefaultConnectionProvider {
     constructor(driver) {
         this.#driver = driver;
     }
-    async provideConnection(runner) {
+    async provideConnection(consumer) {
         const connection = await this.#driver.acquireConnection();
         try {
-            return await runner(connection);
+            return await consumer(connection);
         }
         finally {
             await this.#driver.releaseConnection(connection);

package/dist/cjs/driver/dummy-driver.d.ts

@@ -27,6 +27,14 @@ import { Driver } from './driver.js';
  *   },
  * })
  * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
  */
 export declare class DummyDriver implements Driver {
     /**

package/dist/cjs/driver/dummy-driver.js

@@ -28,6 +28,14 @@ exports.DummyDriver = void 0;
  *   },
  * })
  * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
  */
 class DummyDriver {
     async init() {

package/dist/cjs/driver/single-connection-provider.d.ts

@@ -7,5 +7,5 @@ export declare class SingleConnectionProvider implements ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    provideConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/driver/single-connection-provider.js

@@ -7,11 +7,11 @@ class SingleConnectionProvider {
     constructor(connection) {
         this.#connection = connection;
     }
-    async provideConnection(runner) {
+    async provideConnection(consumer) {
         while (this.#runningPromise) {
             await this.#runningPromise;
         }
-        const promise = this.#run(runner);
+        const promise = this.#run(consumer);
         this.#runningPromise = promise
             .then(() => {
             this.#runningPromise = undefined;

package/dist/cjs/operation-node/alias-node.d.ts

@@ -9,12 +9,12 @@ export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | Se
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: AliasNodeChild;
-    readonly alias: IdentifierNode;
+    readonly alias: IdentifierNode | RawNode;
 }
 /**
  * @internal
  */
 export declare const AliasNode: Readonly<{
     is(node: OperationNode): node is AliasNode;
-    create(node: AliasNodeChild, alias: string): AliasNode;
+    create(node: AliasNodeChild, alias: IdentifierNode | RawNode): AliasNode;
 }>;

package/dist/cjs/operation-node/alias-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const identifier_node_js_1 = require("./identifier-node.js");
 /**
  * @internal
  */
@@ -14,7 +13,7 @@ exports.AliasNode = (0, object_utils_js_1.freeze)({
         return (0, object_utils_js_1.freeze)({
             kind: 'AliasNode',
             node,
-            alias: identifier_node_js_1.IdentifierNode.create(alias),
+            alias,
         });
     },
 });

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -333,6 +333,7 @@ class OperationNodeTransformer {
         return {
             kind: 'UpdateQueryNode',
             table: this.transformNode(node.table),
+            from: this.transformNode(node.from),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),

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

@@ -7,10 +7,12 @@ import { ReturningNode } from './returning-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { FromNode } from './from-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table: TableExpressionNode;
+    readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
@@ -23,5 +25,6 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: TableExpressionNode, withNode?: WithNode | undefined): UpdateQueryNode;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
 }>;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateQueryNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const from_node_js_1 = require("./from-node.js");
 /**
  * @internal
  */
@@ -10,11 +11,19 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'UpdateQueryNode';
     },
     create(table, withNode) {
-        return {
+        return (0, object_utils_js_1.freeze)({
             kind: 'UpdateQueryNode',
             table,
             ...(withNode && { with: withNode }),
-        };
+        });
+    },
+    cloneWithFromItems(updateQuery, fromItems) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            from: updateQuery.from
+                ? from_node_js_1.FromNode.cloneWithFroms(updateQuery.from, fromItems)
+                : from_node_js_1.FromNode.create(fromItems),
+        });
     },
     cloneWithUpdates(updateQuery, updates) {
         return (0, object_utils_js_1.freeze)({

package/dist/cjs/parser/complex-expression-parser.d.ts

@@ -1,7 +1,7 @@
-import { RawBuilder } from '../index-nodeless.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 export declare type ComplexExpression<DB, TB extends keyof DB, V = any> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | RawBuilder<V> | RawBuilderFactory<DB, TB>;
 export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;

package/dist/cjs/parser/reference-parser.js

@@ -8,6 +8,7 @@ const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 function parseReferenceExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -50,7 +51,7 @@ function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
     if (ref.includes(ALIAS_SEPARATOR)) {
         const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
-        return alias_node_js_1.AliasNode.create(parseStringReference(columnRef), alias);
+        return alias_node_js_1.AliasNode.create(parseStringReference(columnRef), identifier_node_js_1.IdentifierNode.create(alias));
     }
     else {
         return parseStringReference(ref);

package/dist/cjs/parser/table-parser.js

@@ -5,6 +5,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
 const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 function parseTableExpressionOrList(table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -27,7 +28,7 @@ function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
         const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
-        return alias_node_js_1.AliasNode.create(parseTable(table), alias);
+        return alias_node_js_1.AliasNode.create(parseTable(table), identifier_node_js_1.IdentifierNode.create(alias));
     }
     else {
         return parseTable(from);

package/dist/cjs/parser/update-set-parser.d.ts

@@ -1,7 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
-export declare type MutationObject<DB, TB extends keyof DB> = {
-    [C in UpdateKeys<DB[TB]>]?: ValueExpression<DB, TB, UpdateType<DB[TB][C]>>;
+export declare type MutationObject<DB, TB extends keyof DB, TM extends keyof DB> = {
+    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>>;
 };
-export declare function parseUpdateObject(row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObject(row: MutationObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/cjs/parser/with-parser.d.ts

@@ -8,14 +8,14 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.d.ts

@@ -1,6 +1,7 @@
-import { DeleteQueryNode, UpdateQueryNode } from '../../index-nodeless.js';
+import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { SelectQueryNode } from '../../operation-node/select-query-node.js';
+import { UpdateQueryNode } from '../../operation-node/update-query-node.js';
 export declare class DeduplicateJoinsTransformer extends OperationNodeTransformer {
     #private;
     protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;

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

@@ -46,7 +46,13 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -62,8 +68,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -71,6 +77,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -78,8 +86,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

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

@@ -3,7 +3,7 @@ import { TableExpression, TableExpressionDatabase, TableExpressionTables } from
 import { FunctionBuilder } from './function-builder.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { QueryExecutor } from '../index-nodeless.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);

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

@@ -9,8 +9,8 @@ const query_id_js_1 = require("../util/query-id.js");
 const function_builder_js_1 = require("./function-builder.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
-const index_nodeless_js_1 = require("../index-nodeless.js");
 const object_utils_js_1 = require("../util/object-utils.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
 class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -100,7 +100,7 @@ class ExpressionBuilder {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             plugins: this.#props.executor.plugins,
-            rawNode: index_nodeless_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(reference)),
+            rawNode: raw_node_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(reference)),
         });
     }
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionBuilder = void 0;
-const index_nodeless_js_1 = require("../index-nodeless.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 const query_id_js_1 = require("../util/query-id.js");
@@ -153,7 +153,7 @@ class FunctionBuilder {
     #oneArgFunction(fn, column) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
-            rawNode: index_nodeless_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
+            rawNode: raw_node_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
         });
     }
 }

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

@@ -382,7 +382,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .onDuplicateKeyUpdate({ species: 'hamster' })
      * ```
      */
-    onDuplicateKeyUpdate(updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onDuplicateKeyUpdate(updates: MutationObject<DB, TB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -69,7 +69,13 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -85,8 +91,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -94,6 +100,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -101,8 +109,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling
@@ -379,7 +386,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
@@ -426,7 +433,13 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -442,8 +455,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -451,6 +464,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -458,8 +473,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

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

@@ -45,7 +45,13 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -61,8 +67,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -70,6 +76,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -77,8 +85,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling
@@ -1205,7 +1212,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -1214,6 +1221,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as<A extends string>(alias: A): AliasedQueryBuilder<DB, TB, O, A>;

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

@@ -15,6 +15,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const group_by_parser_js_1 = require("../parser/group-by-parser.js");
 const union_parser_js_1 = require("../parser/union-parser.js");
 const no_result_error_js_1 = require("./no-result-error.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -515,7 +516,7 @@ class SelectQueryBuilder {
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -524,6 +525,8 @@ class SelectQueryBuilder {
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as(alias) {
@@ -613,10 +616,7 @@ class AliasedQueryBuilder {
     }
     toOperationNode() {
         const node = this.#queryBuilder.toOperationNode();
-        if (select_query_node_js_1.SelectQueryNode.is(node)) {
-            return alias_node_js_1.AliasNode.create(node, this.#alias);
-        }
-        throw new Error('only select queries can be aliased');
+        return alias_node_js_1.AliasNode.create(node, identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
 }
 exports.AliasedQueryBuilder = AliasedQueryBuilder;