kysely 0.25.0 → 0.26.0

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

@@ -1,7 +1,14 @@
 import { AliasNode } from '../operation-node/alias-node.js';
+import { AndNode } from '../operation-node/and-node.js';
 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 { 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<T> implements Expression<T> {
+export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Expression<T> {
     #private;
     constructor(node: OperationNode);
     /** @private */
@@ -31,8 +38,8 @@ export declare class ExpressionWrapper<T> implements Expression<T> {
      * ```ts
      * const result = await db
      *   .selectFrom('person')
-     *   .select(eb =>
-     *     eb.cmpr('first_name', '=', 'Jennifer').as('is_jennifer')
+     *   .select((eb) =>
+     *     eb('first_name', '=', 'Jennifer').as('is_jennifer')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -50,12 +57,136 @@ export declare class ExpressionWrapper<T> implements Expression<T> {
     as<A extends string>(alias: A): AliasedExpression<T, A>;
     as<A extends string>(alias: Expression<unknown>): AliasedExpression<T, A>;
     /**
-     * Change the output type of the raw expression.
+     * Combines `this` and another expression using `OR`.
+     *
+     * Also see {@link ExpressionBuilder.or}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where(eb => eb('first_name', '=', 'Jennifer')
+     *     .or('first_name', '=', 'Arnold')
+     *     .or('first_name', '=', 'Sylvester')
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   or "first_name" = $2
+     *   or "first_name" = $3
+     * )
+     * ```
+     *
+     * You can also pass any expression as the only argument to
+     * this method:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where(eb => eb('first_name', '=', 'Jennifer')
+     *     .or(eb('first_name', '=', 'Sylvester').and('last_name', '=', 'Stallone'))
+     *     .or(eb.exists(
+     *       eb.selectFrom('pet')
+     *         .select('id')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *     )
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   or ("first_name" = $2 and "last_name" = $3)
+     *   or exists (
+     *     select "id"
+     *     from "pet"
+     *     where "pet"."owner_id" = "person"."id"
+     *   )
+     * )
+     * ```
+     */
+    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'>;
+    /**
+     * Combines `this` and another expression using `AND`.
+     *
+     * Also see {@link ExpressionBuilder.and}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where(eb => eb('first_name', '=', 'Jennifer')
+     *     .and('last_name', '=', 'Aniston')
+     *     .and('age', '>', 40)
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = $2
+     *   and "age" > $3
+     * )
+     * ```
+     *
+     * You can also pass any expression as the only argument to
+     * this method:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where(eb => eb('first_name', '=', 'Jennifer')
+     *     .and(eb('first_name', '=', 'Sylvester').or('last_name', '=', 'Stallone'))
+     *     .and(eb.exists(
+     *       eb.selectFrom('pet')
+     *         .select('id')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *     )
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and ("first_name" = $2 or "last_name" = $3)
+     *   and exists (
+     *     select "id"
+     *     from "pet"
+     *     where "pet"."owner_id" = "person"."id"
+     *   )
+     * )
+     * ```
+     */
+    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'>;
+    /**
+     * Change the output type of the expression.
      *
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `ExpressionWrapper` with a new output type.
      */
-    $castTo<T>(): ExpressionWrapper<T>;
+    $castTo<T>(): ExpressionWrapper<DB, TB, T>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -90,3 +221,163 @@ 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> {
+    #private;
+    constructor(node: OrNode);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): T | undefined;
+    /**
+     * Returns an aliased version of the 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(eb =>
+     *     eb('first_name', '=', 'Jennifer')
+     *       .or('first_name', '=', 'Sylvester')
+     *       .as('is_jennifer_or_sylvester')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `is_jennifer_or_sylvester: SqlBool` field exists in the result type.
+     * console.log(result.is_jennifer_or_sylvester)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select "first_name" = $1 or "first_name" = $2 as "is_jennifer_or_sylvester"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedExpression<T, A>;
+    as<A extends string>(alias: Expression<unknown>): AliasedExpression<T, A>;
+    /**
+     * Combines `this` and another expression using `OR`.
+     *
+     * 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>;
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `OrWrapper` with a new output type.
+     */
+    $castTo<T extends SqlBool>(): OrWrapper<DB, TB, T>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): ParensNode;
+}
+export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> implements Expression<T> {
+    #private;
+    constructor(node: AndNode);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): T | undefined;
+    /**
+     * Returns an aliased version of the 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(eb =>
+     *     eb('first_name', '=', 'Jennifer')
+     *       .and('last_name', '=', 'Aniston')
+     *       .as('is_jennifer_aniston')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `is_jennifer_aniston: SqlBool` field exists in the result type.
+     * console.log(result.is_jennifer_or_sylvester)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select "first_name" = $1 and "first_name" = $2 as "is_jennifer_aniston"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedExpression<T, A>;
+    as<A extends string>(alias: Expression<unknown>): AliasedExpression<T, A>;
+    /**
+     * Combines `this` and another expression using `AND`.
+     *
+     * 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>;
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AndWrapper` with a new output type.
+     */
+    $castTo<T extends SqlBool>(): AndWrapper<DB, TB, T>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): ParensNode;
+}

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

@@ -1,7 +1,11 @@
 /// <reference types="./expression-wrapper.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
+import { AndNode } from '../operation-node/and-node.js';
 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';
 export class ExpressionWrapper {
     #node;
     constructor(node) {
@@ -14,8 +18,14 @@ export class ExpressionWrapper {
     as(alias) {
         return new AliasedExpressionWrapper(this, alias);
     }
+    or(...args) {
+        return new OrWrapper(OrNode.create(this.#node, parseFilter(args)));
+    }
+    and(...args) {
+        return new AndWrapper(AndNode.create(this.#node, parseFilter(args)));
+    }
     /**
-     * Change the output type of the raw expression.
+     * Change the output type of the expression.
      *
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `ExpressionWrapper` with a new output type.
@@ -48,3 +58,59 @@ export class AliasedExpressionWrapper {
             : IdentifierNode.create(this.#alias));
     }
 }
+export class OrWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    or(...args) {
+        return new OrWrapper(OrNode.create(this.#node, parseFilter(args)));
+    }
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `OrWrapper` with a new output type.
+     */
+    $castTo() {
+        return new OrWrapper(this.#node);
+    }
+    toOperationNode() {
+        return ParensNode.create(this.#node);
+    }
+}
+export class AndWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    and(...args) {
+        return new AndWrapper(AndNode.create(this.#node, parseFilter(args)));
+    }
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AndWrapper` with a new output type.
+     */
+    $castTo() {
+        return new AndWrapper(this.#node);
+    }
+    toOperationNode() {
+        return ParensNode.create(this.#node);
+    }
+}

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

@@ -4,13 +4,23 @@ import { Simplify } from '../util/type-utils.js';
 /**
  * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
  *
- * 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 arrays.
- *
  * ### Examples
  *
+ * <!-- siteExample("select", "Nested array", 110) -->
+ *
+ * While kysely is not an ORM and it doesn't have the concept of relations, we do provide
+ * helpers for fetching nested objects and arrays in a single query. In this example we
+ * use the `jsonArrayFrom` helper to fetch person's pets along with the person's id.
+ *
+ * Please keep in mind that the helpers under the `kysely/helpers` folder, including
+ * `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.
+ *
  * ```ts
+ * import { jsonArrayFrom } from 'kysely/helpers/postgres'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [
@@ -18,15 +28,11 @@ 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')
  *   ])
  *   .execute()
- *
- * result[0].id
- * result[0].pets[0].pet_id
- * result[0].pets[0].name
  * ```
  *
  * The generated SQL (PostgreSQL):
@@ -49,13 +55,23 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  *
  * The subquery must only return one row.
  *
- * 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.
- *
  * ### Examples
  *
+ * <!-- siteExample("select", "Nested object", 120) -->
+ *
+ * While kysely is not an ORM and it doesn't have the concept of relations, we do provide
+ * helpers for fetching nested objects and arrays in a single query. In this example we
+ * 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
+ * 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.
+ *
  * ```ts
+ * import { jsonObjectFrom } from 'kysely/helpers/postgres'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [
@@ -63,15 +79,11 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  *     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')
  *   ])
  *   .execute()
- *
- * result[0].id
- * result[0].favorite_pet.pet_id
- * result[0].favorite_pet.name
  * ```
  *
  * The generated SQL (PostgreSQL):

package/dist/esm/helpers/postgres.js

@@ -3,13 +3,23 @@ import { sql } from '../raw-builder/sql.js';
 /**
  * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
  *
- * 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 arrays.
- *
  * ### Examples
  *
+ * <!-- siteExample("select", "Nested array", 110) -->
+ *
+ * While kysely is not an ORM and it doesn't have the concept of relations, we do provide
+ * helpers for fetching nested objects and arrays in a single query. In this example we
+ * use the `jsonArrayFrom` helper to fetch person's pets along with the person's id.
+ *
+ * Please keep in mind that the helpers under the `kysely/helpers` folder, including
+ * `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.
+ *
  * ```ts
+ * import { jsonArrayFrom } from 'kysely/helpers/postgres'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [
@@ -17,15 +27,11 @@ 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')
  *   ])
  *   .execute()
- *
- * result[0].id
- * result[0].pets[0].pet_id
- * result[0].pets[0].name
  * ```
  *
  * The generated SQL (PostgreSQL):
@@ -50,13 +56,23 @@ export function jsonArrayFrom(expr) {
  *
  * The subquery must only return one row.
  *
- * 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.
- *
  * ### Examples
  *
+ * <!-- siteExample("select", "Nested object", 120) -->
+ *
+ * While kysely is not an ORM and it doesn't have the concept of relations, we do provide
+ * helpers for fetching nested objects and arrays in a single query. In this example we
+ * 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
+ * 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.
+ *
  * ```ts
+ * import { jsonObjectFrom } from 'kysely/helpers/postgres'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [
@@ -64,15 +80,11 @@ 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')
  *   ])
  *   .execute()
- *
- * result[0].id
- * result[0].favorite_pet.pet_id
- * result[0].favorite_pet.name
  * ```
  *
  * The generated SQL (PostgreSQL):

package/dist/esm/index.d.ts

@@ -19,6 +19,7 @@ export * from './query-builder/update-result.js';
 export * from './query-builder/on-conflict-builder.js';
 export * from './query-builder/aggregate-function-builder.js';
 export * from './query-builder/case-builder.js';
+export * from './query-builder/json-path-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './raw-builder/sql.js';
 export * from './query-executor/query-executor.js';
@@ -79,6 +80,7 @@ export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
 export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
 export * from './plugin/with-schema/with-schema-plugin.js';
+export * from './plugin/parse-json-results/parse-json-results-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';
@@ -164,6 +166,10 @@ export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
 export * from './operation-node/using-node.js';
+export * from './operation-node/json-reference-node.js';
+export * from './operation-node/json-path-leg-node.js';
+export * from './operation-node/json-path-node.js';
+export * from './operation-node/json-operator-chain-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';

package/dist/esm/index.js

@@ -20,6 +20,7 @@ export * from './query-builder/update-result.js';
 export * from './query-builder/on-conflict-builder.js';
 export * from './query-builder/aggregate-function-builder.js';
 export * from './query-builder/case-builder.js';
+export * from './query-builder/json-path-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './raw-builder/sql.js';
 export * from './query-executor/query-executor.js';
@@ -80,6 +81,7 @@ export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
 export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
 export * from './plugin/with-schema/with-schema-plugin.js';
+export * from './plugin/parse-json-results/parse-json-results-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';
@@ -165,6 +167,10 @@ export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
 export * from './operation-node/using-node.js';
+export * from './operation-node/json-reference-node.js';
+export * from './operation-node/json-path-leg-node.js';
+export * from './operation-node/json-path-node.js';
+export * from './operation-node/json-operator-chain-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';