kysely 0.26.1 → 0.26.2

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

@@ -6,8 +6,9 @@ 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')
  *   ])
@@ -54,8 +55,9 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>):
  * 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')
  *   ])
@@ -100,8 +102,9 @@ export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>)
  * 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.');
+    }
 }

package/dist/esm/helpers/postgres.d.ts

@@ -16,7 +16,8 @@ import { Simplify } from '../util/type-utils.js';
  * `jsonArrayFrom`, are not guaranteed to work with third party dialects. In order for
  * them to work, the dialect must automatically parse the `json` data type into
  * javascript JSON values like objects and arrays. Some dialects might simply return
- * the data as a JSON string.
+ * the data as a JSON string. In these cases you can use the built in `ParseJSONResultsPlugin`
+ * to parse the results.
  *
  * ```ts
  * import { jsonArrayFrom } from 'kysely/helpers/postgres'
@@ -64,10 +65,11 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  * use the `jsonObjectFrom` helper to fetch person's favorite pet along with the person's id.
  *
  * Please keep in mind that the helpers under the `kysely/helpers` folder, including
- * `jsonObjectFrom`, are not guaranteed to work with third party dialects. In order for
+ * `jsonObjectFrom`, are not guaranteed to work with 3rd party dialects. In order for
  * them to work, the dialect must automatically parse the `json` data type into
  * javascript JSON values like objects and arrays. Some dialects might simply return
- * the data as a JSON string.
+ * the data as a JSON string. In these cases you can use the built in `ParseJSONResultsPlugin`
+ * to parse the results.
  *
  * ```ts
  * import { jsonObjectFrom } from 'kysely/helpers/postgres'
@@ -105,8 +107,9 @@ export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simpl
  * The PostgreSQL `json_build_object` function.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
- * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
- * may not parse the nested results into objects.
+ * While the produced SQL is compatible with all PostgreSQL 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/postgres.js

@@ -15,7 +15,8 @@ import { sql } from '../raw-builder/sql.js';
  * `jsonArrayFrom`, are not guaranteed to work with third party dialects. In order for
  * them to work, the dialect must automatically parse the `json` data type into
  * javascript JSON values like objects and arrays. Some dialects might simply return
- * the data as a JSON string.
+ * the data as a JSON string. In these cases you can use the built in `ParseJSONResultsPlugin`
+ * to parse the results.
  *
  * ```ts
  * import { jsonArrayFrom } from 'kysely/helpers/postgres'
@@ -65,10 +66,11 @@ export function jsonArrayFrom(expr) {
  * use the `jsonObjectFrom` helper to fetch person's favorite pet along with the person's id.
  *
  * Please keep in mind that the helpers under the `kysely/helpers` folder, including
- * `jsonObjectFrom`, are not guaranteed to work with third party dialects. In order for
+ * `jsonObjectFrom`, are not guaranteed to work with 3rd party dialects. In order for
  * them to work, the dialect must automatically parse the `json` data type into
  * javascript JSON values like objects and arrays. Some dialects might simply return
- * the data as a JSON string.
+ * the data as a JSON string. In these cases you can use the built in `ParseJSONResultsPlugin`
+ * to parse the results.
  *
  * ```ts
  * import { jsonObjectFrom } from 'kysely/helpers/postgres'
@@ -108,8 +110,9 @@ export function jsonObjectFrom(expr) {
  * The PostgreSQL `json_build_object` function.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
- * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
- * may not parse the nested results into objects.
+ * While the produced SQL is compatible with all PostgreSQL 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
  *