kysely 0.17.3 → 0.19.0

package/dist/cjs/migration/migrator.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migrator = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
+exports.Migrator = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.DEFAULT_MIGRATION_LOCK_TABLE = exports.DEFAULT_MIGRATION_TABLE = void 0;
+const noop_plugin_js_1 = require("../plugin/noop-plugin.js");
+const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-exports.MIGRATION_TABLE = 'kysely_migration';
-exports.MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
+exports.DEFAULT_MIGRATION_TABLE = 'kysely_migration';
+exports.DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 exports.MIGRATION_LOCK_ID = 'migration_lock';
 exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true });
 /**
@@ -37,9 +39,10 @@ class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(exports.MIGRATION_TABLE))
+        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
             ? await this.#props.db
-                .selectFrom(exports.MIGRATION_TABLE)
+                .withPlugin(this.#schemaPlugin)
+                .selectFrom(this.#migrationTable)
                 .select(['name', 'timestamp'])
                 .execute()
             : [];
@@ -184,16 +187,61 @@ class Migrator {
             return { error };
         }
     }
+    get #migrationTableSchema() {
+        return this.#props.migrationTableSchema;
+    }
+    get #migrationTable() {
+        return this.#props.migrationTableName ?? exports.DEFAULT_MIGRATION_TABLE;
+    }
+    get #migrationLockTable() {
+        return this.#props.migrationLockTableName ?? exports.DEFAULT_MIGRATION_LOCK_TABLE;
+    }
+    get #schemaPlugin() {
+        if (this.#migrationTableSchema) {
+            return new with_schema_plugin_js_1.WithSchemaPlugin(this.#migrationTableSchema);
+        }
+        return new noop_plugin_js_1.NoopPlugin();
+    }
     async #ensureMigrationTablesExists() {
+        await this.#ensureMigrationTableSchemaExists();
         await this.#ensureMigrationTableExists();
         await this.#ensureMigrationLockTableExists();
         await this.#ensureLockRowExists();
     }
+    async #ensureMigrationTableSchemaExists() {
+        if (!this.#migrationTableSchema) {
+            // Use default schema. Nothing to do.
+            return;
+        }
+        if (!(await this.#doesSchemaExists())) {
+            try {
+                await this.#props.db.schema
+                    .createSchema(this.#migrationTableSchema)
+                    .ifNotExists()
+                    .execute();
+            }
+            catch (error) {
+                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+                // query doesn't throw if the schema already exits. That's why we check if
+                // the schema exist here and ignore the error if it does.
+                if (!(await this.#doesSchemaExists())) {
+                    throw error;
+                }
+            }
+        }
+    }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
+        if (!(await this.#doesTableExists(this.#migrationTable))) {
             try {
+                if (this.#migrationTableSchema) {
+                    await this.#props.db.schema
+                        .createSchema(this.#migrationTableSchema)
+                        .ifNotExists()
+                        .execute();
+                }
                 await this.#props.db.schema
-                    .createTable(exports.MIGRATION_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .createTable(this.#migrationTable)
                     .ifNotExists()
                     .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
                     // The migration run time as ISO string. This is not a real date type as we
@@ -205,17 +253,18 @@ class Migrator {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
                 // query doesn't throw if the table already exits. That's why we check if
                 // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
+                if (!(await this.#doesTableExists(this.#migrationTable))) {
                     throw error;
                 }
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
+        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
             try {
                 await this.#props.db.schema
-                    .createTable(exports.MIGRATION_LOCK_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .createTable(this.#migrationLockTable)
                     .ifNotExists()
                     .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
                     .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
@@ -225,7 +274,7 @@ class Migrator {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
                 // query doesn't throw if the table already exits. That's why we check if
                 // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
+                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
                     throw error;
                 }
             }
@@ -235,7 +284,8 @@ class Migrator {
         if (!(await this.#doesLockRowExists())) {
             try {
                 await this.#props.db
-                    .insertInto(exports.MIGRATION_LOCK_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .insertInto(this.#migrationLockTable)
                     .values({ id: exports.MIGRATION_LOCK_ID, is_locked: 0 })
                     .execute();
             }
@@ -246,15 +296,21 @@ class Migrator {
             }
         }
     }
+    async #doesSchemaExists() {
+        const schemas = await this.#props.db.introspection.getSchemas();
+        return schemas.some((it) => it.name === this.#migrationTableSchema);
+    }
     async #doesTableExists(tableName) {
-        const metadata = await this.#props.db.introspection.getMetadata({
+        const schema = this.#migrationTableSchema;
+        const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,
         });
-        return !!metadata.tables.find((it) => it.name === tableName);
+        return tables.some((it) => it.name === tableName && (!schema || it.schema === schema));
     }
     async #doesLockRowExists() {
         const lockRow = await this.#props.db
-            .selectFrom(exports.MIGRATION_LOCK_TABLE)
+            .withPlugin(this.#schemaPlugin)
+            .selectFrom(this.#migrationLockTable)
             .where('id', '=', exports.MIGRATION_LOCK_ID)
             .select('id')
             .executeTakeFirst();
@@ -312,7 +368,8 @@ class Migrator {
     }
     async #getExecutedMigrations(db) {
         const executedMigrations = await db
-            .selectFrom(exports.MIGRATION_TABLE)
+            .withPlugin(this.#schemaPlugin)
+            .selectFrom(this.#migrationTable)
             .select('name')
             .orderBy('name')
             .execute();
@@ -348,7 +405,8 @@ class Migrator {
                 if (migration.down) {
                     await migration.down(db);
                     await db
-                        .deleteFrom(exports.MIGRATION_TABLE)
+                        .withPlugin(this.#schemaPlugin)
+                        .deleteFrom(this.#migrationTable)
                         .where('name', '=', migration.name)
                         .execute();
                     results[i] = {
@@ -386,7 +444,8 @@ class Migrator {
             try {
                 await migration.up(db);
                 await db
-                    .insertInto(exports.MIGRATION_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .insertInto(this.#migrationTable)
                     .values({
                     name: migration.name,
                     timestamp: new Date().toISOString(),

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/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/noop-plugin.d.ts

@@ -0,0 +1,42 @@
+import { QueryResult } from '../driver/database-connection.js';
+import { RootOperationNode } from '../query-compiler/query-compiler.js';
+import { UnknownRow } from '../util/type-utils.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from './kysely-plugin.js';
+export declare class NoopPlugin implements KyselyPlugin {
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/cjs/plugin/noop-plugin.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopPlugin = void 0;
+class NoopPlugin {
+    transformQuery(args) {
+        return args.node;
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}
+exports.NoopPlugin = NoopPlugin;

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

@@ -386,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;

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

@@ -1212,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')
@@ -1221,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;