kysely 0.25.0 → 0.26.1

package/dist/esm/kysely.d.ts

@@ -89,16 +89,14 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * calls.
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * await db.selectFrom('person')
      *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   .select([
+     *   .select((eb) => [
      *     'person.id',
-     *     count('pet.id').as('pet_count')
+     *     eb.fn.count('pet.id').as('pet_count')
      *   ])
      *   .groupBy('person.id')
-     *   .having(count('pet.id'), '>', 10)
+     *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
      *   .execute()
      * ```
      *
@@ -129,23 +127,29 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *
      * ### Examples
      *
+     * <!-- siteExample("transactions", "Simple transaction", 10) -->
+     *
+     * This example inserts two rows in a transaction. If an error is thrown inside
+     * the callback passed to the `execute` method, the transaction is rolled back.
+     * Otherwise it's committed.
+     *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
      *       first_name: 'Jennifer',
      *       last_name: 'Aniston',
+     *       age: 40,
      *     })
      *     .returning('id')
      *     .executeTakeFirstOrThrow()
      *
-     *   await someFunction(trx, jennifer)
-     *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer.id,
+     *       owner_id: jennifer.id,
      *       name: 'Catto',
-     *       species: 'cat'
+     *       species: 'cat',
+     *       is_favorite: false,
      *     })
      *     .returningAll()
      *     .executeTakeFirst()
@@ -274,23 +278,29 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *
      * ### Examples
      *
+     * <!-- siteExample("transactions", "Simple transaction", 10) -->
+     *
+     * This example inserts two rows in a transaction. If an error is thrown inside
+     * the callback passed to the `execute` method, the transaction is rolled back.
+     * Otherwise it's committed.
+     *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
      *       first_name: 'Jennifer',
      *       last_name: 'Aniston',
+     *       age: 40,
      *     })
      *     .returning('id')
      *     .executeTakeFirstOrThrow()
      *
-     *   await someFunction(trx, jennifer)
-     *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer.id,
+     *       owner_id: jennifer.id,
      *       name: 'Catto',
-     *       species: 'cat'
+     *       species: 'cat',
+     *       is_favorite: false,
      *     })
      *     .returningAll()
      *     .executeTakeFirst()

package/dist/esm/kysely.js

@@ -120,16 +120,14 @@ export class Kysely extends QueryCreator {
      * calls.
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * await db.selectFrom('person')
      *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   .select([
+     *   .select((eb) => [
      *     'person.id',
-     *     count('pet.id').as('pet_count')
+     *     eb.fn.count('pet.id').as('pet_count')
      *   ])
      *   .groupBy('person.id')
-     *   .having(count('pet.id'), '>', 10)
+     *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
      *   .execute()
      * ```
      *
@@ -162,23 +160,29 @@ export class Kysely extends QueryCreator {
      *
      * ### Examples
      *
+     * <!-- siteExample("transactions", "Simple transaction", 10) -->
+     *
+     * This example inserts two rows in a transaction. If an error is thrown inside
+     * the callback passed to the `execute` method, the transaction is rolled back.
+     * Otherwise it's committed.
+     *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
      *       first_name: 'Jennifer',
      *       last_name: 'Aniston',
+     *       age: 40,
      *     })
      *     .returning('id')
      *     .executeTakeFirstOrThrow()
      *
-     *   await someFunction(trx, jennifer)
-     *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer.id,
+     *       owner_id: jennifer.id,
      *       name: 'Catto',
-     *       species: 'cat'
+     *       species: 'cat',
+     *       is_favorite: false,
      *     })
      *     .returningAll()
      *     .executeTakeFirst()

package/dist/esm/operation-node/alter-column-node.d.ts

@@ -1,7 +1,7 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { RawNode } from './raw-node.js';
-export declare type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
+export type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
     readonly kind: 'AlterColumnNode';
     readonly column: ColumnNode;
@@ -17,6 +17,5 @@ export interface AlterColumnNode extends OperationNode {
  */
 export declare const AlterColumnNode: Readonly<{
     is(node: OperationNode): node is AlterColumnNode;
-    create(column: string): AlterColumnNode;
-    cloneWith(node: AlterColumnNode, props: AlterColumnNodeProps): AlterColumnNode;
+    create<T extends "dataType" | "dataTypeExpression" | "setDefault" | "dropDefault" | "setNotNull" | "dropNotNull">(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): AlterColumnNode;
 }>;

package/dist/esm/operation-node/alter-column-node.js

@@ -8,16 +8,11 @@ export const AlterColumnNode = freeze({
     is(node) {
         return node.kind === 'AlterColumnNode';
     },
-    create(column) {
+    create(column, prop, value) {
         return freeze({
             kind: 'AlterColumnNode',
             column: ColumnNode.create(column),
-        });
-    },
-    cloneWith(node, props) {
-        return freeze({
-            ...node,
-            ...props,
+            [prop]: value,
         });
     },
 });

package/dist/esm/operation-node/alter-table-node.d.ts

@@ -8,8 +8,8 @@ import { AlterColumnNode } from './alter-column-node.js';
 import { AddConstraintNode } from './add-constraint-node.js';
 import { DropConstraintNode } from './drop-constraint-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
-export declare type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint'>;
-export declare type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
+export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint'>;
+export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
     readonly kind: 'AlterTableNode';
     readonly table: TableNode;

package/dist/esm/operation-node/column-definition-node.d.ts

@@ -4,7 +4,7 @@ import { DefaultValueNode } from './default-value-node.js';
 import { GeneratedNode } from './generated-node.js';
 import { OperationNode } from './operation-node.js';
 import { ReferencesNode } from './references-node.js';
-export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
+export type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
     readonly column: ColumnNode;

package/dist/esm/operation-node/constraint-node.d.ts

@@ -2,4 +2,4 @@ import { CheckConstraintNode } from './check-constraint-node.js';
 import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { PrimaryKeyConstraintNode } from './primary-constraint-node.js';
 import { UniqueConstraintNode } from './unique-constraint-node.js';
-export declare type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;
+export type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;

package/dist/esm/operation-node/create-index-node.d.ts

@@ -3,8 +3,8 @@ import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { TableNode } from './table-node.js';
 import { WhereNode } from './where-node.js';
-export declare type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
-export declare type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
+export type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
+export type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
 export interface CreateIndexNode extends OperationNode {
     readonly kind: 'CreateIndexNode';
     readonly name: IdentifierNode;

package/dist/esm/operation-node/create-schema-node.d.ts

@@ -1,6 +1,6 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
+export type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
 export interface CreateSchemaNode extends OperationNode {
     readonly kind: 'CreateSchemaNode';
     readonly schema: IdentifierNode;

package/dist/esm/operation-node/create-table-node.d.ts

@@ -4,8 +4,8 @@ import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ArrayItemType } from '../util/type-utils.js';
 export declare const ON_COMMIT_ACTIONS: string[];
-export declare type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
-export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
+export type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
+export type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;

package/dist/esm/operation-node/create-type-node.d.ts

@@ -1,7 +1,7 @@
 import { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { ValueListNode } from './value-list-node.js';
-export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
 export interface CreateTypeNode extends OperationNode {
     readonly kind: 'CreateTypeNode';
     readonly name: SchemableIdentifierNode;

package/dist/esm/operation-node/create-view-node.d.ts

@@ -3,7 +3,7 @@ import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { SelectQueryNode } from './select-query-node.js';
-export declare type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
+export type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
     readonly name: SchemableIdentifierNode;

package/dist/esm/operation-node/data-type-node.d.ts

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'char' | `char(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | `binary(${number})` | 'bytea' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
-export declare type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
+export type ColumnDataType = 'varchar' | `varchar(${number})` | 'char' | `char(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | `binary(${number})` | 'bytea' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
+export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
     readonly dataType: ColumnDataType;

package/dist/esm/operation-node/drop-constraint-node.d.ts

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { IdentifierNode } from './identifier-node.js';
-export declare type DropConstraintNodeProps = Omit<DropConstraintNode, 'kind' | 'constraintName'>;
+export type DropConstraintNodeProps = Omit<DropConstraintNode, 'kind' | 'constraintName'>;
 export interface DropConstraintNode extends OperationNode {
     readonly kind: 'DropConstraintNode';
     readonly constraintName: IdentifierNode;

package/dist/esm/operation-node/drop-index-node.d.ts

@@ -1,7 +1,7 @@
 import { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { TableNode } from './table-node.js';
-export declare type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
+export type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
     readonly name: SchemableIdentifierNode;

package/dist/esm/operation-node/drop-schema-node.d.ts

@@ -1,6 +1,6 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type DropSchemaNodeParams = Omit<Partial<DropSchemaNode>, 'kind' | 'schema'>;
+export type DropSchemaNodeParams = Omit<Partial<DropSchemaNode>, 'kind' | 'schema'>;
 export interface DropSchemaNode extends OperationNode {
     readonly kind: 'DropSchemaNode';
     readonly schema: IdentifierNode;

package/dist/esm/operation-node/drop-table-node.d.ts

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
-export declare type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+export type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
     readonly table: TableNode;

package/dist/esm/operation-node/drop-type-node.d.ts

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
+export type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
 export interface DropTypeNode extends OperationNode {
     readonly kind: 'DropTypeNode';
     readonly name: SchemableIdentifierNode;

package/dist/esm/operation-node/drop-view-node.d.ts

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-export declare type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
+export type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
 export interface DropViewNode extends OperationNode {
     readonly kind: 'DropViewNode';
     readonly name: SchemableIdentifierNode;

package/dist/esm/operation-node/foreign-key-constraint-node.d.ts

@@ -3,7 +3,7 @@ import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
 import { TableNode } from './table-node.js';
-export declare type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
+export type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;

package/dist/esm/operation-node/generated-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
+export type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
 export interface GeneratedNode extends OperationNode {
     readonly kind: 'GeneratedNode';
     readonly byDefault?: boolean;

package/dist/esm/operation-node/insert-query-node.d.ts

@@ -6,7 +6,7 @@ import { OperationNode } from './operation-node.js';
 import { ReturningNode } from './returning-node.js';
 import { TableNode } from './table-node.js';
 import { WithNode } from './with-node.js';
-export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
+export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;

package/dist/esm/operation-node/join-node.d.ts

@@ -1,6 +1,6 @@
 import { OnNode } from './on-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
+export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;
@@ -15,5 +15,4 @@ export declare const JoinNode: Readonly<{
     create(joinType: JoinType, table: OperationNode): JoinNode;
     createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): JoinNode;
     cloneWithOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
-    cloneWithOrOn(joinNode: JoinNode, operation: OperationNode): JoinNode;
 }>;

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

@@ -32,12 +32,4 @@ export const JoinNode = freeze({
                 : OnNode.create(operation),
         });
     },
-    cloneWithOrOn(joinNode, operation) {
-        return freeze({
-            ...joinNode,
-            on: joinNode.on
-                ? OnNode.cloneWithOperation(joinNode.on, 'Or', operation)
-                : OnNode.create(operation),
-        });
-    },
 });

package/dist/esm/operation-node/json-operator-chain-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { OperatorNode } from './operator-node.js';
+import { ValueNode } from './value-node.js';
+export interface JSONOperatorChainNode extends OperationNode {
+    readonly kind: 'JSONOperatorChainNode';
+    readonly operator: OperatorNode;
+    readonly values: readonly ValueNode[];
+}
+/**
+ * @internal
+ */
+export declare const JSONOperatorChainNode: Readonly<{
+    is(node: OperationNode): node is JSONOperatorChainNode;
+    create(operator: OperatorNode): JSONOperatorChainNode;
+    cloneWithValue(node: JSONOperatorChainNode, value: ValueNode): JSONOperatorChainNode;
+}>;

package/dist/esm/operation-node/json-operator-chain-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-operator-chain-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONOperatorChainNode = freeze({
+    is(node) {
+        return node.kind === 'JSONOperatorChainNode';
+    },
+    create(operator) {
+        return freeze({
+            kind: 'JSONOperatorChainNode',
+            operator,
+            values: freeze([]),
+        });
+    },
+    cloneWithValue(node, value) {
+        return freeze({
+            ...node,
+            values: freeze([...node.values, value]),
+        });
+    },
+});

package/dist/esm/operation-node/json-path-leg-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export type JSONPathLegType = 'Member' | 'ArrayLocation';
+export interface JSONPathLegNode extends OperationNode {
+    readonly kind: 'JSONPathLegNode';
+    readonly type: JSONPathLegType;
+    readonly value: string | number;
+}
+/**
+ * @internal
+ */
+export declare const JSONPathLegNode: Readonly<{
+    is(node: OperationNode): node is JSONPathLegNode;
+    create(type: JSONPathLegType, value: string | number): JSONPathLegNode;
+}>;

package/dist/esm/operation-node/json-path-leg-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./json-path-leg-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONPathLegNode = freeze({
+    is(node) {
+        return node.kind === 'JSONPathLegNode';
+    },
+    create(type, value) {
+        return freeze({
+            kind: 'JSONPathLegNode',
+            type,
+            value,
+        });
+    },
+});

package/dist/esm/operation-node/json-path-node.d.ts

@@ -0,0 +1,16 @@
+import { JSONPathLegNode } from './json-path-leg-node.js';
+import { OperationNode } from './operation-node.js';
+import { OperatorNode } from './operator-node.js';
+export interface JSONPathNode extends OperationNode {
+    readonly kind: 'JSONPathNode';
+    readonly inOperator?: OperatorNode;
+    readonly pathLegs: ReadonlyArray<JSONPathLegNode>;
+}
+/**
+ * @internal
+ */
+export declare const JSONPathNode: Readonly<{
+    is(node: OperationNode): node is JSONPathNode;
+    create(inOperator?: OperatorNode): JSONPathNode;
+    cloneWithLeg(jsonPathNode: JSONPathNode, pathLeg: JSONPathLegNode): JSONPathNode;
+}>;

package/dist/esm/operation-node/json-path-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-path-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONPathNode = freeze({
+    is(node) {
+        return node.kind === 'JSONPathNode';
+    },
+    create(inOperator) {
+        return freeze({
+            kind: 'JSONPathNode',
+            inOperator,
+            pathLegs: freeze([]),
+        });
+    },
+    cloneWithLeg(jsonPathNode, pathLeg) {
+        return freeze({
+            ...jsonPathNode,
+            pathLegs: freeze([...jsonPathNode.pathLegs, pathLeg]),
+        });
+    },
+});

package/dist/esm/operation-node/json-reference-node.d.ts

@@ -0,0 +1,17 @@
+import { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import { JSONPathNode } from './json-path-node.js';
+import { OperationNode } from './operation-node.js';
+import { ReferenceNode } from './reference-node.js';
+export interface JSONReferenceNode extends OperationNode {
+    readonly kind: 'JSONReferenceNode';
+    readonly reference: ReferenceNode;
+    readonly traversal: JSONPathNode | JSONOperatorChainNode;
+}
+/**
+ * @internal
+ */
+export declare const JSONReferenceNode: Readonly<{
+    is(node: OperationNode): node is JSONReferenceNode;
+    create(reference: ReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): JSONReferenceNode;
+    cloneWithTraversal(node: JSONReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): JSONReferenceNode;
+}>;

package/dist/esm/operation-node/json-reference-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-reference-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONReferenceNode = freeze({
+    is(node) {
+        return node.kind === 'JSONReferenceNode';
+    },
+    create(reference, traversal) {
+        return freeze({
+            kind: 'JSONReferenceNode',
+            reference,
+            traversal,
+        });
+    },
+    cloneWithTraversal(node, traversal) {
+        return freeze({
+            ...node,
+            traversal,
+        });
+    },
+});

package/dist/esm/operation-node/on-conflict-node.d.ts

@@ -3,7 +3,7 @@ import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { WhereNode } from './where-node.js';
-export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
+export type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;

package/dist/esm/operation-node/on-duplicate-key-node.d.ts

@@ -1,6 +1,6 @@
 import { ColumnUpdateNode } from './column-update-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>;
+export type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>;
 export interface OnDuplicateKeyNode extends OperationNode {
     readonly kind: 'OnDuplicateKeyNode';
     readonly updates: ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -80,6 +80,10 @@ import { UsingNode } from './using-node.js';
 import { FunctionNode } from './function-node.js';
 import { CaseNode } from './case-node.js';
 import { WhenNode } from './when-node.js';
+import { JSONReferenceNode } from './json-reference-node.js';
+import { JSONPathNode } from './json-path-node.js';
+import { JSONPathLegNode } from './json-path-leg-node.js';
+import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -189,6 +193,10 @@ export declare class OperationNodeTransformer {
     protected transformFunction(node: FunctionNode): FunctionNode;
     protected transformCase(node: CaseNode): CaseNode;
     protected transformWhen(node: WhenNode): WhenNode;
+    protected transformJSONReference(node: JSONReferenceNode): JSONReferenceNode;
+    protected transformJSONPath(node: JSONPathNode): JSONPathNode;
+    protected transformJSONPathLeg(node: JSONPathLegNode): JSONPathLegNode;
+    protected transformJSONOperatorChain(node: JSONOperatorChainNode): JSONOperatorChainNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;