kysely 0.26.1 → 0.26.3

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

@@ -1,24 +1,26 @@
 /// <reference types="./expression-builder.d.ts" />
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { createSelectQueryBuilder, } from '../query-builder/select-query-builder.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { createFunctionModule, } from '../query-builder/function-module.js';
 import { parseJSONReference, parseReferenceExpression, parseStringReference, } from '../parser/reference-parser.js';
-import { parseValueBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
-import { AndNode } from '../operation-node/and-node.js';
-import { OrNode } from '../operation-node/or-node.js';
+import { parseFilterList, parseFilterObject, parseValueBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
 import { ParensNode } from '../operation-node/parens-node.js';
 import { ExpressionWrapper } from './expression-wrapper.js';
+import { OperatorNode, } from '../operation-node/operator-node.js';
 import { parseUnaryOperation } from '../parser/unary-operation-parser.js';
-import { parseValueExpressionOrList, } from '../parser/value-parser.js';
+import { parseSafeImmediateValue, parseValueExpression, parseValueExpressionOrList, } from '../parser/value-parser.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
-import { ValueNode } from '../operation-node/value-node.js';
 import { CaseBuilder } from '../query-builder/case-builder.js';
 import { CaseNode } from '../operation-node/case-node.js';
-import { isUndefined } from '../util/object-utils.js';
+import { isReadonlyArray, isUndefined } from '../util/object-utils.js';
 import { JSONPathBuilder } from '../query-builder/json-path-builder.js';
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { AndNode } from '../operation-node/and-node.js';
+import { parseSelectArg, } from '../parser/select-parser.js';
+import { TupleNode } from '../operation-node/tuple-node.js';
 export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
     function binary(lhs, op, rhs) {
         return new ExpressionWrapper(parseValueBinaryOperation(lhs, op, rhs));
@@ -30,10 +32,17 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
         fn: undefined,
         eb: undefined,
         selectFrom(table) {
-            return new SelectQueryBuilder({
+            return createSelectQueryBuilder({
                 queryId: createQueryId(),
-                executor: executor,
-                queryNode: SelectQueryNode.create(parseTableExpressionOrList(table)),
+                executor,
+                queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList(table)),
+            });
+        },
+        selectNoFrom(selection) {
+            return createSelectQueryBuilder({
+                queryId: createQueryId(),
+                executor,
+                queryNode: SelectQueryNode.cloneWithSelections(SelectQueryNode.create(), parseSelectArg(selection)),
             });
         },
         case(reference) {
@@ -52,6 +61,15 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
         val(value) {
             return new ExpressionWrapper(parseValueExpressionOrList(value));
         },
+        refTuple(...values) {
+            return new ExpressionWrapper(TupleNode.create(values.map(parseReferenceExpression)));
+        },
+        tuple(...values) {
+            return new ExpressionWrapper(TupleNode.create(values.map(parseValueExpression)));
+        },
+        lit(value) {
+            return new ExpressionWrapper(parseSafeImmediateValue(value));
+        },
         // @deprecated
         cmpr(lhs, op, rhs) {
             return new ExpressionWrapper(parseValueBinaryOperation(lhs, op, rhs));
@@ -70,31 +88,23 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
         neg(expr) {
             return unary('-', expr);
         },
+        between(expr, start, end) {
+            return new ExpressionWrapper(BinaryOperationNode.create(parseReferenceExpression(expr), OperatorNode.create('between'), AndNode.create(parseValueExpression(start), parseValueExpression(end))));
+        },
+        betweenSymmetric(expr, start, end) {
+            return new ExpressionWrapper(BinaryOperationNode.create(parseReferenceExpression(expr), OperatorNode.create('between symmetric'), AndNode.create(parseValueExpression(start), parseValueExpression(end))));
+        },
         and(exprs) {
-            if (exprs.length === 0) {
-                return new ExpressionWrapper(ValueNode.createImmediate(true));
-            }
-            else if (exprs.length === 1) {
-                return new ExpressionWrapper(exprs[0].toOperationNode());
+            if (isReadonlyArray(exprs)) {
+                return new ExpressionWrapper(parseFilterList(exprs, 'and'));
             }
-            let node = AndNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
-            for (let i = 2; i < exprs.length; ++i) {
-                node = AndNode.create(node, exprs[i].toOperationNode());
-            }
-            return new ExpressionWrapper(ParensNode.create(node));
+            return new ExpressionWrapper(parseFilterObject(exprs, 'and'));
         },
         or(exprs) {
-            if (exprs.length === 0) {
-                return new ExpressionWrapper(ValueNode.createImmediate(false));
-            }
-            else if (exprs.length === 1) {
-                return new ExpressionWrapper(exprs[0].toOperationNode());
-            }
-            let node = OrNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
-            for (let i = 2; i < exprs.length; ++i) {
-                node = OrNode.create(node, exprs[i].toOperationNode());
+            if (isReadonlyArray(exprs)) {
+                return new ExpressionWrapper(parseFilterList(exprs, 'or'));
             }
-            return new ExpressionWrapper(ParensNode.create(node));
+            return new ExpressionWrapper(parseFilterObject(exprs, 'or'));
         },
         parens(...args) {
             const node = parseValueBinaryOperationOrExpression(args);

package/dist/esm/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/esm/expression/expression-wrapper.js

@@ -5,7 +5,7 @@ import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OrNode } from '../operation-node/or-node.js';
 import { ParensNode } from '../operation-node/parens-node.js';
-import { parseFilter, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
 export class ExpressionWrapper {
     #node;
     constructor(node) {
@@ -19,10 +19,10 @@ export class ExpressionWrapper {
         return new AliasedExpressionWrapper(this, alias);
     }
     or(...args) {
-        return new OrWrapper(OrNode.create(this.#node, parseFilter(args)));
+        return new OrWrapper(OrNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
     }
     and(...args) {
-        return new AndWrapper(AndNode.create(this.#node, parseFilter(args)));
+        return new AndWrapper(AndNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
     }
     /**
      * Change the output type of the expression.
@@ -71,7 +71,7 @@ export class OrWrapper {
         return new AliasedExpressionWrapper(this, alias);
     }
     or(...args) {
-        return new OrWrapper(OrNode.create(this.#node, parseFilter(args)));
+        return new OrWrapper(OrNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
     }
     /**
      * Change the output type of the expression.
@@ -99,7 +99,7 @@ export class AndWrapper {
         return new AliasedExpressionWrapper(this, alias);
     }
     and(...args) {
-        return new AndWrapper(AndNode.create(this.#node, parseFilter(args)));
+        return new AndWrapper(AndNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
     }
     /**
      * Change the output type of the expression.

package/dist/esm/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/esm/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/esm/helpers/mysql.js

@@ -1,15 +1,13 @@
 /// <reference types="./mysql.d.ts" />
-import { AliasNode } from '../operation-node/alias-node.js';
-import { ColumnNode } from '../operation-node/column-node.js';
-import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { ReferenceNode } from '../operation-node/reference-node.js';
 import { sql } from '../raw-builder/sql.js';
+import { getJsonObjectArgs } from '../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
  *
@@ -21,7 +19,7 @@ import { sql } from '../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')
  *   ])
@@ -50,7 +48,7 @@ import { sql } from '../raw-builder/sql.js';
  * ```
  */
 export function jsonArrayFrom(expr) {
-    return sql `(select cast(coalesce(json_arrayagg(json_object(${sql.join(getJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') as json) from ${expr} as agg)`;
+    return sql `(select cast(coalesce(json_arrayagg(json_object(${sql.join(getMysqlJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') as json) from ${expr} as agg)`;
 }
 /**
  * A MySQL helper for turning a subquery into a JSON object.
@@ -58,8 +56,9 @@ export function jsonArrayFrom(expr) {
  * 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
  *
@@ -71,7 +70,7 @@ export function jsonArrayFrom(expr) {
  *     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')
  *   ])
@@ -100,14 +99,15 @@ export function jsonArrayFrom(expr) {
  * ```
  */
 export function jsonObjectFrom(expr) {
-    return sql `(select json_object(${sql.join(getJsonObjectArgs(expr.toOperationNode(), 'obj'))}) from ${expr} as obj)`;
+    return sql `(select json_object(${sql.join(getMysqlJsonObjectArgs(expr.toOperationNode(), 'obj'))}) from ${expr} as obj)`;
 }
 /**
  * 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
  *
@@ -144,22 +144,11 @@ export function jsonObjectFrom(expr) {
 export function jsonBuildObject(obj) {
     return sql `json_object(${sql.join(Object.keys(obj).flatMap((k) => [sql.lit(k), obj[k]]))})`;
 }
-function getJsonObjectArgs(node, table) {
-    return node.selections.flatMap(({ selection: s }) => {
-        if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
-            return [
-                sql.lit(s.column.column.name),
-                sql.id(table, s.column.column.name),
-            ];
-        }
-        else if (ColumnNode.is(s)) {
-            return [sql.lit(s.column.name), sql.id(table, s.column.name)];
-        }
-        else if (AliasNode.is(s) && IdentifierNode.is(s.alias)) {
-            return [sql.lit(s.alias.name), 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 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.');
+    }
 }