kysely 0.26.1 → 0.26.3

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

@@ -9,18 +9,20 @@ const query_id_js_1 = require("../util/query-id.js");
 const function_module_js_1 = require("../query-builder/function-module.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
-const and_node_js_1 = require("../operation-node/and-node.js");
-const or_node_js_1 = require("../operation-node/or-node.js");
 const parens_node_js_1 = require("../operation-node/parens-node.js");
 const expression_wrapper_js_1 = require("./expression-wrapper.js");
+const operator_node_js_1 = require("../operation-node/operator-node.js");
 const unary_operation_parser_js_1 = require("../parser/unary-operation-parser.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
 const case_builder_js_1 = require("../query-builder/case-builder.js");
 const case_node_js_1 = require("../operation-node/case-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const json_path_builder_js_1 = require("../query-builder/json-path-builder.js");
+const binary_operation_node_js_1 = require("../operation-node/binary-operation-node.js");
+const and_node_js_1 = require("../operation-node/and-node.js");
+const select_parser_js_1 = require("../parser/select-parser.js");
+const tuple_node_js_1 = require("../operation-node/tuple-node.js");
 function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_EXECUTOR) {
     function binary(lhs, op, rhs) {
         return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
@@ -32,10 +34,17 @@ function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_
         fn: undefined,
         eb: undefined,
         selectFrom(table) {
-            return new select_query_builder_js_1.SelectQueryBuilder({
+            return (0, select_query_builder_js_1.createSelectQueryBuilder)({
                 queryId: (0, query_id_js_1.createQueryId)(),
-                executor: executor,
-                queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(table)),
+                executor,
+                queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)(table)),
+            });
+        },
+        selectNoFrom(selection) {
+            return (0, select_query_builder_js_1.createSelectQueryBuilder)({
+                queryId: (0, query_id_js_1.createQueryId)(),
+                executor,
+                queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(select_query_node_js_1.SelectQueryNode.create(), (0, select_parser_js_1.parseSelectArg)(selection)),
             });
         },
         case(reference) {
@@ -54,6 +63,15 @@ function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_
         val(value) {
             return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseValueExpressionOrList)(value));
         },
+        refTuple(...values) {
+            return new expression_wrapper_js_1.ExpressionWrapper(tuple_node_js_1.TupleNode.create(values.map(reference_parser_js_1.parseReferenceExpression)));
+        },
+        tuple(...values) {
+            return new expression_wrapper_js_1.ExpressionWrapper(tuple_node_js_1.TupleNode.create(values.map(value_parser_js_1.parseValueExpression)));
+        },
+        lit(value) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseSafeImmediateValue)(value));
+        },
         // @deprecated
         cmpr(lhs, op, rhs) {
             return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
@@ -72,31 +90,23 @@ function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_
         neg(expr) {
             return unary('-', expr);
         },
+        between(expr, start, end) {
+            return new expression_wrapper_js_1.ExpressionWrapper(binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(expr), operator_node_js_1.OperatorNode.create('between'), and_node_js_1.AndNode.create((0, value_parser_js_1.parseValueExpression)(start), (0, value_parser_js_1.parseValueExpression)(end))));
+        },
+        betweenSymmetric(expr, start, end) {
+            return new expression_wrapper_js_1.ExpressionWrapper(binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(expr), operator_node_js_1.OperatorNode.create('between symmetric'), and_node_js_1.AndNode.create((0, value_parser_js_1.parseValueExpression)(start), (0, value_parser_js_1.parseValueExpression)(end))));
+        },
         and(exprs) {
-            if (exprs.length === 0) {
-                return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(true));
-            }
-            else if (exprs.length === 1) {
-                return new expression_wrapper_js_1.ExpressionWrapper(exprs[0].toOperationNode());
+            if ((0, object_utils_js_1.isReadonlyArray)(exprs)) {
+                return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterList)(exprs, 'and'));
             }
-            let node = and_node_js_1.AndNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
-            for (let i = 2; i < exprs.length; ++i) {
-                node = and_node_js_1.AndNode.create(node, exprs[i].toOperationNode());
-            }
-            return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
+            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterObject)(exprs, 'and'));
         },
         or(exprs) {
-            if (exprs.length === 0) {
-                return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(false));
-            }
-            else if (exprs.length === 1) {
-                return new expression_wrapper_js_1.ExpressionWrapper(exprs[0].toOperationNode());
-            }
-            let node = or_node_js_1.OrNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
-            for (let i = 2; i < exprs.length; ++i) {
-                node = or_node_js_1.OrNode.create(node, exprs[i].toOperationNode());
+            if ((0, object_utils_js_1.isReadonlyArray)(exprs)) {
+                return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterList)(exprs, 'or'));
             }
-            return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
+            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseFilterObject)(exprs, 'or'));
         },
         parens(...args) {
             const node = (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args);

package/dist/cjs/expression/expression-wrapper.d.ts

@@ -4,11 +4,12 @@ import { OperationNode } from '../operation-node/operation-node.js';
 import { OrNode } from '../operation-node/or-node.js';
 import { ParensNode } from '../operation-node/parens-node.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { OperandExpression } from '../parser/expression-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { SqlBool } from '../util/type-utils.js';
-import { AliasedExpression, Expression } from './expression.js';
-export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Expression<T> {
+import { AliasableExpression, AliasedExpression, Expression } from './expression.js';
+export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements AliasableExpression<T> {
     #private;
     constructor(node: OperationNode);
     /** @private */
@@ -55,6 +56,62 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Ex
      * ```
      */
     as<A extends string>(alias: A): AliasedExpression<T, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name' eb.val(' '), '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", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) 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: Expression<unknown>): AliasedExpression<T, A>;
     /**
      * Combines `this` and another expression using `OR`.
@@ -117,7 +174,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Ex
      * ```
      */
     or<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
-    or(expression: Expression<SqlBool>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
+    or(expression: OperandExpression<SqlBool>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
     /**
      * Combines `this` and another expression using `AND`.
      *
@@ -179,7 +236,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Ex
      * ```
      */
     and<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
-    and(expression: Expression<SqlBool>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
+    and(expression: OperandExpression<SqlBool>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
     /**
      * Change the output type of the expression.
      *
@@ -221,7 +278,7 @@ export declare class AliasedExpressionWrapper<T, A extends string> implements Al
      */
     toOperationNode(): AliasNode;
 }
-export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> implements Expression<T> {
+export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> implements AliasableExpression<T> {
     #private;
     constructor(node: OrNode);
     /** @private */
@@ -270,6 +327,62 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      * ```
      */
     as<A extends string>(alias: A): AliasedExpression<T, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name' eb.val(' '), '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", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) 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: Expression<unknown>): AliasedExpression<T, A>;
     /**
      * Combines `this` and another expression using `OR`.
@@ -277,7 +390,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      * See {@link ExpressionWrapper.or} for examples.
      */
     or<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OrWrapper<DB, TB, T>;
-    or(expression: Expression<SqlBool>): OrWrapper<DB, TB, T>;
+    or(expression: OperandExpression<SqlBool>): OrWrapper<DB, TB, T>;
     /**
      * Change the output type of the expression.
      *
@@ -301,7 +414,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      */
     toOperationNode(): ParensNode;
 }
-export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> implements Expression<T> {
+export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> implements AliasableExpression<T> {
     #private;
     constructor(node: AndNode);
     /** @private */
@@ -350,6 +463,62 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      * ```
      */
     as<A extends string>(alias: A): AliasedExpression<T, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name' eb.val(' '), '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", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) 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: Expression<unknown>): AliasedExpression<T, A>;
     /**
      * Combines `this` and another expression using `AND`.
@@ -357,7 +526,7 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      * See {@link ExpressionWrapper.and} for examples.
      */
     and<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AndWrapper<DB, TB, T>;
-    and(expression: Expression<SqlBool>): AndWrapper<DB, TB, T>;
+    and(expression: OperandExpression<SqlBool>): AndWrapper<DB, TB, T>;
     /**
      * Change the output type of the expression.
      *

package/dist/cjs/expression/expression-wrapper.js

@@ -21,10 +21,10 @@ class ExpressionWrapper {
         return new AliasedExpressionWrapper(this, alias);
     }
     or(...args) {
-        return new OrWrapper(or_node_js_1.OrNode.create(this.#node, (0, binary_operation_parser_js_1.parseFilter)(args)));
+        return new OrWrapper(or_node_js_1.OrNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
     }
     and(...args) {
-        return new AndWrapper(and_node_js_1.AndNode.create(this.#node, (0, binary_operation_parser_js_1.parseFilter)(args)));
+        return new AndWrapper(and_node_js_1.AndNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
     }
     /**
      * Change the output type of the expression.
@@ -75,7 +75,7 @@ class OrWrapper {
         return new AliasedExpressionWrapper(this, alias);
     }
     or(...args) {
-        return new OrWrapper(or_node_js_1.OrNode.create(this.#node, (0, binary_operation_parser_js_1.parseFilter)(args)));
+        return new OrWrapper(or_node_js_1.OrNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
     }
     /**
      * Change the output type of the expression.
@@ -104,7 +104,7 @@ class AndWrapper {
         return new AliasedExpressionWrapper(this, alias);
     }
     and(...args) {
-        return new AndWrapper(and_node_js_1.AndNode.create(this.#node, (0, binary_operation_parser_js_1.parseFilter)(args)));
+        return new AndWrapper(and_node_js_1.AndNode.create(this.#node, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)));
     }
     /**
      * Change the output type of the expression.

package/dist/cjs/expression/expression.d.ts

@@ -49,7 +49,70 @@ export interface Expression<T> extends OperationNodeSource {
     toOperationNode(): OperationNode;
 }
 /**
- * Just like `Expression<T>` but also holds an alias type `A`.
+ * An expression with an `as` method.
+ */
+export interface AliasableExpression<T> extends Expression<T> {
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name' eb.val(' '), '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", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) 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): AliasedExpression<T, A>;
+    as<A extends string>(alias: Expression<any>): AliasedExpression<T, A>;
+}
+/**
+ * A type that holds an expression and an alias for it.
  *
  * `AliasedExpression<T, A>` can be used in places where, in addition to the value type `T`, you
  * also need a name `A` for that value. For example anything you can pass into the `select` method

package/dist/cjs/helpers/mysql.d.ts

@@ -1,13 +1,14 @@
 import { Expression } from '../expression/expression.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { Simplify } from '../util/type-utils.js';
 /**
  * A MySQL helper for aggregating a subquery into a JSON array.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
- * may not parse the nested results into arrays.
+ * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
+ * may not parse the nested JSON into arrays. In these cases you can use the built in
+ * `ParseJSONResultsPlugin` to parse the results.
  *
  * ### Examples
  *
@@ -19,7 +20,7 @@ import { Simplify } from '../util/type-utils.js';
  *     jsonArrayFrom(
  *       eb.selectFrom('pet')
  *         .select(['pet.id as pet_id', 'pet.name'])
- *         .where('pet.owner_id', '=', 'person.id')
+ *         .whereRef('pet.owner_id', '=', 'person.id')
  *         .orderBy('pet.name')
  *     ).as('pets')
  *   ])
@@ -47,15 +48,16 @@ import { Simplify } from '../util/type-utils.js';
  * from `person`
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O>[]>;
 /**
  * A MySQL helper for turning a subquery into a JSON object.
  *
  * The subquery must only return one row.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
- * may not parse the nested results into objects.
+ * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
+ * may not parse the nested JSON into objects. In these cases you can use the built in
+ * `ParseJSONResultsPlugin` to parse the results.
  *
  * ### Examples
  *
@@ -67,7 +69,7 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>):
  *     jsonObjectFrom(
  *       eb.selectFrom('pet')
  *         .select(['pet.id as pet_id', 'pet.name'])
- *         .where('pet.owner_id', '=', 'person.id')
+ *         .whereRef('pet.owner_id', '=', 'person.id')
  *         .where('pet.is_favorite', '=', true)
  *     ).as('favorite_pet')
  *   ])
@@ -95,13 +97,14 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>):
  * from `person`
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O> | null>;
 /**
  * The MySQL `json_object` function.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
- * may not parse the nested results into objects.
+ * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
+ * may not parse the nested JSON into objects. In these cases you can use the built in
+ * `ParseJSONResultsPlugin` to parse the results.
  *
  * ### Examples
  *

package/dist/cjs/helpers/mysql.js

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.jsonBuildObject = exports.jsonObjectFrom = exports.jsonArrayFrom = void 0;
-const alias_node_js_1 = require("../operation-node/alias-node.js");
-const column_node_js_1 = require("../operation-node/column-node.js");
-const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const reference_node_js_1 = require("../operation-node/reference-node.js");
 const sql_js_1 = require("../raw-builder/sql.js");
+const json_object_args_js_1 = require("../util/json-object-args.js");
 /**
  * A MySQL helper for aggregating a subquery into a JSON array.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
- * may not parse the nested results into arrays.
+ * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
+ * may not parse the nested JSON into arrays. In these cases you can use the built in
+ * `ParseJSONResultsPlugin` to parse the results.
  *
  * ### Examples
  *
@@ -23,7 +21,7 @@ const sql_js_1 = require("../raw-builder/sql.js");
  *     jsonArrayFrom(
  *       eb.selectFrom('pet')
  *         .select(['pet.id as pet_id', 'pet.name'])
- *         .where('pet.owner_id', '=', 'person.id')
+ *         .whereRef('pet.owner_id', '=', 'person.id')
  *         .orderBy('pet.name')
  *     ).as('pets')
  *   ])
@@ -52,7 +50,7 @@ const sql_js_1 = require("../raw-builder/sql.js");
  * ```
  */
 function jsonArrayFrom(expr) {
-    return (0, sql_js_1.sql) `(select cast(coalesce(json_arrayagg(json_object(${sql_js_1.sql.join(getJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') as json) from ${expr} as agg)`;
+    return (0, sql_js_1.sql) `(select cast(coalesce(json_arrayagg(json_object(${sql_js_1.sql.join(getMysqlJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') as json) from ${expr} as agg)`;
 }
 exports.jsonArrayFrom = jsonArrayFrom;
 /**
@@ -61,8 +59,9 @@ exports.jsonArrayFrom = jsonArrayFrom;
  * The subquery must only return one row.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
- * may not parse the nested results into objects.
+ * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
+ * may not parse the nested JSON into objects. In these cases you can use the built in
+ * `ParseJSONResultsPlugin` to parse the results.
  *
  * ### Examples
  *
@@ -74,7 +73,7 @@ exports.jsonArrayFrom = jsonArrayFrom;
  *     jsonObjectFrom(
  *       eb.selectFrom('pet')
  *         .select(['pet.id as pet_id', 'pet.name'])
- *         .where('pet.owner_id', '=', 'person.id')
+ *         .whereRef('pet.owner_id', '=', 'person.id')
  *         .where('pet.is_favorite', '=', true)
  *     ).as('favorite_pet')
  *   ])
@@ -103,15 +102,16 @@ exports.jsonArrayFrom = jsonArrayFrom;
  * ```
  */
 function jsonObjectFrom(expr) {
-    return (0, sql_js_1.sql) `(select json_object(${sql_js_1.sql.join(getJsonObjectArgs(expr.toOperationNode(), 'obj'))}) from ${expr} as obj)`;
+    return (0, sql_js_1.sql) `(select json_object(${sql_js_1.sql.join(getMysqlJsonObjectArgs(expr.toOperationNode(), 'obj'))}) from ${expr} as obj)`;
 }
 exports.jsonObjectFrom = jsonObjectFrom;
 /**
  * The MySQL `json_object` function.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
- * may not parse the nested results into objects.
+ * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
+ * may not parse the nested JSON into objects. In these cases you can use the built in
+ * `ParseJSONResultsPlugin` to parse the results.
  *
  * ### Examples
  *
@@ -149,22 +149,11 @@ function jsonBuildObject(obj) {
     return (0, sql_js_1.sql) `json_object(${sql_js_1.sql.join(Object.keys(obj).flatMap((k) => [sql_js_1.sql.lit(k), obj[k]]))})`;
 }
 exports.jsonBuildObject = jsonBuildObject;
-function getJsonObjectArgs(node, table) {
-    return node.selections.flatMap(({ selection: s }) => {
-        if (reference_node_js_1.ReferenceNode.is(s) && column_node_js_1.ColumnNode.is(s.column)) {
-            return [
-                sql_js_1.sql.lit(s.column.column.name),
-                sql_js_1.sql.id(table, s.column.column.name),
-            ];
-        }
-        else if (column_node_js_1.ColumnNode.is(s)) {
-            return [sql_js_1.sql.lit(s.column.name), sql_js_1.sql.id(table, s.column.name)];
-        }
-        else if (alias_node_js_1.AliasNode.is(s) && identifier_node_js_1.IdentifierNode.is(s.alias)) {
-            return [sql_js_1.sql.lit(s.alias.name), sql_js_1.sql.id(table, s.alias.name)];
-        }
-        else {
-            throw new Error('MySQL jsonArrayFrom and jsonObjectFrom functions can only handle explicit selections due to limitations of the json_object function. selectAll() is not allowed in the subquery.');
-        }
-    });
+function getMysqlJsonObjectArgs(node, table) {
+    try {
+        return (0, json_object_args_js_1.getJsonObjectArgs)(node, table);
+    }
+    catch {
+        throw new Error('MySQL jsonArrayFrom and jsonObjectFrom functions can only handle explicit selections due to limitations of the json_object function. selectAll() is not allowed in the subquery.');
+    }
 }