kysely 0.17.1 → 0.18.0

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

@@ -1,61 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryExecutor = void 0;
-const object_utils_js_1 = require("../util/object-utils.js");
-const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
-/**
- * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
- * and other classes that execute queries can just pass around and instance of
- * `QueryExecutor`.
- */
-class QueryExecutor {
-    #plugins;
-    constructor(plugins) {
-        this.#plugins = plugins ?? NO_PLUGINS;
-    }
-    get plugins() {
-        return this.#plugins;
-    }
-    /**
-     * Given the query the user has built (expressed as an operation node tree)
-     * this method runs it through all plugins' `transformQuery` methods and
-     * returns the result.
-     */
-    transformQuery(node, queryId) {
-        for (const plugin of this.#plugins) {
-            const transformedNode = plugin.transformQuery({ node, queryId });
-            // We need to do a runtime check here. There is no good way
-            // to write types that enforce this constraint.
-            if (transformedNode.kind === node.kind) {
-                node = transformedNode;
-            }
-            else {
-                throw new Error([
-                    `KyselyPlugin.transformQuery must return a node`,
-                    `of the same kind that was given to it.`,
-                    `The plugin was given a ${node.kind}`,
-                    `but it returned a ${transformedNode.kind}`,
-                ].join(' '));
-            }
-        }
-        return node;
-    }
-    /**
-     * Executes a compiled query and runs the result through all plugins'
-     * `transformResult` method.
-     */
-    async executeQuery(compiledQuery, queryId) {
-        return await this.provideConnection(async (connection) => {
-            const result = await connection.executeQuery(compiledQuery);
-            return this.#transformResult(result, queryId);
-        });
-    }
-    async #transformResult(result, queryId) {
-        for (const plugin of this.#plugins) {
-            result = await plugin.transformResult({ result, queryId });
-        }
-        return result;
-    }
-}
-exports.QueryExecutor = QueryExecutor;

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -38,8 +39,37 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * select concat(first_name, ' ', last_name) as "full_name"
      * from "person"
      * ```
+     *
+     * You can also pass in a raw SQL snippet but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    as<A extends string = never>(alias: AnyRawBuilder): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -67,9 +97,9 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
      * which causes this type to be equal to AliasedRawBuilder with any A
      * as long as O is the same.
      */
-    protected get alias(): A;
+    protected get alias(): A | AnyRawBuilder;
     toOperationNode(): AliasNode;
-    constructor(rawBuilder: RawBuilder<O>, alias: A);
+    constructor(rawBuilder: RawBuilder<O>, alias: A | AnyRawBuilder);
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;

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

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasedRawBuilder = exports.RawBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -16,31 +18,6 @@ class RawBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
-    /**
-     * Returns an aliased version of the SQL expression.
-     *
-     * In addition to slapping `as "the_alias"` to the end of the SQL,
-     * this method also provides strict typing:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select(
-     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     *
-     * // `full_name: string` field exists in the result type.
-     * console.log(result.full_name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```ts
-     * select concat(first_name, ' ', last_name) as "full_name"
-     * from "person"
-     * ```
-     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -103,7 +80,9 @@ class AliasedRawBuilder {
         return this.#alias;
     }
     toOperationNode() {
-        return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), this.#alias);
+        return alias_node_js_1.AliasNode.create(this.#rawBuilder.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
+            ? this.#alias.toOperationNode()
+            : identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;

package/dist/cjs/raw-builder/sql.d.ts

@@ -221,7 +221,7 @@ export interface Sql {
      *   sql.id('first_name')
      * ]
      *
-     * sql`BEFORE ${sql.array(things, sql`::varchar, `)} AFTER`
+     * sql`BEFORE ${sql.join(things, sql`::varchar, `)} AFTER`
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -281,7 +281,7 @@ export interface Sql {
  * from "person"
  * where birthdate between $1 and $2
  * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concate(first_name, ' ', last_name)
+ * order by concat(first_name, ' ', last_name)
  * ```
  *
  * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
@@ -313,7 +313,15 @@ export interface Sql {
  *   .select([
  *     'first_name',
  *     'last_name',
- *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *     (eb) => {
+ *       // The `eb.ref` method is type-safe and only accepts
+ *       // column references that are possible.
+ *       const firstName = eb.ref('first_name')
+ *       const lastName = eb.ref('last_name')
+ *
+ *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+ *       return fullName.as('full_name')
+ *     }
  *   ])
  * ```
  *

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

@@ -58,7 +58,7 @@ const raw_builder_js_1 = require("./raw-builder.js");
  * from "person"
  * where birthdate between $1 and $2
  * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concate(first_name, ' ', last_name)
+ * order by concat(first_name, ' ', last_name)
  * ```
  *
  * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
@@ -90,7 +90,15 @@ const raw_builder_js_1 = require("./raw-builder.js");
  *   .select([
  *     'first_name',
  *     'last_name',
- *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *     (eb) => {
+ *       // The `eb.ref` method is type-safe and only accepts
+ *       // column references that are possible.
+ *       const firstName = eb.ref('first_name')
+ *       const lastName = eb.ref('last_name')
+ *
+ *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+ *       return fullName.as('full_name')
+ *     }
  *   ])
  * ```
  *

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -23,6 +23,13 @@ export declare class AlterTableBuilder {
     alterColumn(column: string): AlterColumnBuilder;
     dropColumn(column: string): AlterTableExecutor;
     renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     *
+     * Unlike {@link CreateTableBuilder.addColumn} this method returns the column builder
+     * and doesn't take a callback as the last argument. This is because you can only
+     * add one column per `ALTER TABLE` query.
+     */
     addColumn(columnName: string, dataType: DataTypeExpression): AlterTableAddColumnBuilder;
     /**
      * Creates an `alter table modify column` query. The `modify column` statement
@@ -30,8 +37,21 @@ export declare class AlterTableBuilder {
      * should use the `alterColumn` method.
      */
     modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
     addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
     addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
@@ -142,7 +162,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'
@@ -306,7 +327,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'

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

@@ -68,6 +68,13 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     *
+     * Unlike {@link CreateTableBuilder.addColumn} this method returns the column builder
+     * and doesn't take a callback as the last argument. This is because you can only
+     * add one column per `ALTER TABLE` query.
+     */
     addColumn(columnName, dataType) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -85,6 +92,9 @@ class AlterTableBuilder {
             columnBuilder: new column_definition_builder_js_1.ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.create(columnName, (0, data_type_parser_js_1.parseDataTypeExpression)(dataType))),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
     addUniqueConstraint(constraintName, columns) {
         return new AlterTableExecutor({
             ...this.#props,
@@ -93,6 +103,9 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
     addCheckConstraint(constraintName, checkExpression) {
         return new AlterTableExecutor({
             ...this.#props,
@@ -101,6 +114,13 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
         return new AlterTableAddForeignKeyConstraintBuilder({
             ...this.#props,

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -83,7 +83,8 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'
@@ -241,7 +242,8 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'

package/dist/cjs/schema/create-table-builder.d.ts

@@ -136,7 +136,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * )
      * ```
      *
-     * Add constraintfor multiple columns:
+     * Add constraint for multiple columns:
      *
      * ```ts
      * addForeignKeyConstraint(

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

@@ -186,7 +186,7 @@ class CreateTableBuilder {
      * )
      * ```
      *
-     * Add constraintfor multiple columns:
+     * Add constraint for multiple columns:
      *
      * ```ts
      * addForeignKeyConstraint(

package/dist/cjs/util/type-utils.d.ts

@@ -74,7 +74,7 @@ export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
  *   movie: Movie
  * }
  *
- * type Columns = AnyColumn<Database, 'person' | 'pet'>
+ * type Columns = AnyColumnWithTable<Database, 'person' | 'pet'>
  *
  * // Columns == 'person.id' | 'pet.name' | 'pet.species'
  * ```

package/dist/esm/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/esm/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/esm/driver/default-connection-provider.js

@@ -4,10 +4,10 @@ export 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/esm/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/esm/driver/dummy-driver.js

@@ -26,6 +26,14 @@
  *   },
  * })
  * ```
+ *
+ * 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 class DummyDriver {
     async init() {

package/dist/esm/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/esm/driver/single-connection-provider.js

@@ -5,11 +5,11 @@ export 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/esm/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/esm/operation-node/alias-node.js

@@ -1,6 +1,5 @@
 /// <reference types="./alias-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
 /**
  * @internal
  */
@@ -12,7 +11,7 @@ export const AliasNode = freeze({
         return freeze({
             kind: 'AliasNode',
             node,
-            alias: IdentifierNode.create(alias),
+            alias,
         });
     },
 });

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

@@ -331,6 +331,7 @@ export 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/esm/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/esm/operation-node/update-query-node.js

@@ -1,5 +1,6 @@
 /// <reference types="./update-query-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { FromNode } from './from-node.js';
 /**
  * @internal
  */
@@ -8,11 +9,19 @@ export const UpdateQueryNode = freeze({
         return node.kind === 'UpdateQueryNode';
     },
     create(table, withNode) {
-        return {
+        return freeze({
             kind: 'UpdateQueryNode',
             table,
             ...(withNode && { with: withNode }),
-        };
+        });
+    },
+    cloneWithFromItems(updateQuery, fromItems) {
+        return freeze({
+            ...updateQuery,
+            from: updateQuery.from
+                ? FromNode.cloneWithFroms(updateQuery.from, fromItems)
+                : FromNode.create(fromItems),
+        });
     },
     cloneWithUpdates(updateQuery, updates) {
         return freeze({

package/dist/esm/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/esm/parser/reference-parser.js

@@ -6,6 +6,7 @@ import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseComplexExpression, } from './complex-expression-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseReferenceExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -45,7 +46,7 @@ export function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
     if (ref.includes(ALIAS_SEPARATOR)) {
         const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseStringReference(columnRef), alias);
+        return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
     }
     else {
         return parseStringReference(ref);

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

@@ -3,6 +3,7 @@ import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
 import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -23,7 +24,7 @@ export function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
         const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseTable(table), alias);
+        return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
     }
     else {
         return parseTable(from);

package/dist/esm/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>;