kysely 0.24.2 → 0.26.0

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

@@ -3,13 +3,13 @@ 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;
     readonly table?: TableNode;
-    readonly expression?: OperationNode;
+    readonly columns?: OperationNode[];
     readonly unique?: boolean;
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
@@ -22,4 +22,5 @@ export declare const CreateIndexNode: Readonly<{
     is(node: OperationNode): node is CreateIndexNode;
     create(name: string): CreateIndexNode;
     cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): CreateIndexNode;
+    cloneWithColumns(node: CreateIndexNode, columns: OperationNode[]): CreateIndexNode;
 }>;

package/dist/cjs/operation-node/create-index-node.js

@@ -22,4 +22,10 @@ exports.CreateIndexNode = (0, object_utils_js_1.freeze)({
             ...props,
         });
     },
+    cloneWithColumns(node, columns) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
 });

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/operation-node/data-type-node.d.ts

@@ -1,6 +1,6 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | '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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/operation-node/join-node.js

@@ -34,12 +34,4 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
                 : on_node_js_1.OnNode.create(operation),
         });
     },
-    cloneWithOrOn(joinNode, operation) {
-        return (0, object_utils_js_1.freeze)({
-            ...joinNode,
-            on: joinNode.on
-                ? on_node_js_1.OnNode.cloneWithOperation(joinNode.on, 'Or', operation)
-                : on_node_js_1.OnNode.create(operation),
-        });
-    },
 });

package/dist/cjs/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/cjs/operation-node/json-operator-chain-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONOperatorChainNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONOperatorChainNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONOperatorChainNode';
+    },
+    create(operator) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONOperatorChainNode',
+            operator,
+            values: (0, object_utils_js_1.freeze)([]),
+        });
+    },
+    cloneWithValue(node, value) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            values: (0, object_utils_js_1.freeze)([...node.values, value]),
+        });
+    },
+});

package/dist/cjs/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/cjs/operation-node/json-path-leg-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONPathLegNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONPathLegNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONPathLegNode';
+    },
+    create(type, value) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONPathLegNode',
+            type,
+            value,
+        });
+    },
+});

package/dist/cjs/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/cjs/operation-node/json-path-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONPathNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONPathNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONPathNode';
+    },
+    create(inOperator) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONPathNode',
+            inOperator,
+            pathLegs: (0, object_utils_js_1.freeze)([]),
+        });
+    },
+    cloneWithLeg(jsonPathNode, pathLeg) {
+        return (0, object_utils_js_1.freeze)({
+            ...jsonPathNode,
+            pathLegs: (0, object_utils_js_1.freeze)([...jsonPathNode.pathLegs, pathLeg]),
+        });
+    },
+});

package/dist/cjs/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/cjs/operation-node/json-reference-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONReferenceNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.JSONReferenceNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'JSONReferenceNode';
+    },
+    create(reference, traversal) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'JSONReferenceNode',
+            reference,
+            traversal,
+        });
+    },
+    cloneWithTraversal(node, traversal) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            traversal,
+        });
+    },
+});

package/dist/cjs/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/cjs/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/cjs/operation-node/operation-node-transformer.d.ts

@@ -78,6 +78,12 @@ import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 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.
  *
@@ -185,6 +191,12 @@ export declare class OperationNodeTransformer {
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
     protected transformUsing(node: UsingNode): UsingNode;
     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;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -114,6 +114,12 @@ class OperationNodeTransformer {
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
         UsingNode: this.transformUsing.bind(this),
         FunctionNode: this.transformFunction.bind(this),
+        CaseNode: this.transformCase.bind(this),
+        WhenNode: this.transformWhen.bind(this),
+        JSONReferenceNode: this.transformJSONReference.bind(this),
+        JSONPathNode: this.transformJSONPath.bind(this),
+        JSONPathLegNode: this.transformJSONPathLeg.bind(this),
+        JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -187,8 +193,8 @@ class OperationNodeTransformer {
     transformReference(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ReferenceNode',
-            table: this.transformNode(node.table),
             column: this.transformNode(node.column),
+            table: this.transformNode(node.table),
         });
     }
     transformAnd(node) {
@@ -404,7 +410,7 @@ class OperationNodeTransformer {
             kind: 'CreateIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
-            expression: this.transformNode(node.expression),
+            columns: this.transformNodeList(node.columns),
             unique: node.unique,
             using: this.transformNode(node.using),
             ifNotExists: node.ifNotExists,
@@ -653,7 +659,7 @@ class OperationNodeTransformer {
     transformAggregateFunction(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AggregateFunctionNode',
-            aggregated: this.transformNode(node.aggregated),
+            aggregated: this.transformNodeList(node.aggregated),
             distinct: node.distinct,
             filter: this.transformNode(node.filter),
             func: node.func,
@@ -707,6 +713,50 @@ class OperationNodeTransformer {
             arguments: this.transformNodeList(node.arguments),
         });
     }
+    transformCase(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'CaseNode',
+            value: this.transformNode(node.value),
+            when: this.transformNodeList(node.when),
+            else: this.transformNode(node.else),
+            isStatement: node.isStatement,
+        });
+    }
+    transformWhen(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'WhenNode',
+            condition: this.transformNode(node.condition),
+            result: this.transformNode(node.result),
+        });
+    }
+    transformJSONReference(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONReferenceNode',
+            reference: this.transformNode(node.reference),
+            traversal: this.transformNode(node.traversal),
+        });
+    }
+    transformJSONPath(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONPathNode',
+            inOperator: this.transformNode(node.inOperator),
+            pathLegs: this.transformNodeList(node.pathLegs),
+        });
+    }
+    transformJSONPathLeg(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONPathLegNode',
+            type: node.type,
+            value: node.value,
+        });
+    }
+    transformJSONOperatorChain(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'JSONOperatorChainNode',
+            operator: this.transformNode(node.operator),
+            values: this.transformNodeList(node.values),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/cjs/operation-node/operation-node-visitor.d.ts

@@ -78,6 +78,12 @@ import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
 import { FunctionNode } from './function-node.js';
+import { WhenNode } from './when-node.js';
+import { CaseNode } from './case-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';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -162,4 +168,10 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
     protected abstract visitUsing(node: UsingNode): void;
     protected abstract visitFunction(node: FunctionNode): void;
+    protected abstract visitCase(node: CaseNode): void;
+    protected abstract visitWhen(node: WhenNode): void;
+    protected abstract visitJSONReference(node: JSONReferenceNode): void;
+    protected abstract visitJSONPath(node: JSONPathNode): void;
+    protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
+    protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
 }

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -87,6 +87,12 @@ class OperationNodeVisitor {
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
         UsingNode: this.visitUsing.bind(this),
         FunctionNode: this.visitFunction.bind(this),
+        CaseNode: this.visitCase.bind(this),
+        WhenNode: this.visitWhen.bind(this),
+        JSONReferenceNode: this.visitJSONReference.bind(this),
+        JSONPathNode: this.visitJSONPath.bind(this),
+        JSONPathLegNode: this.visitJSONPathLeg.bind(this),
+        JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode';
+export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,16 +1,19 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const JSON_OPERATORS: readonly ["->", "->>"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare const UNARY_OPERATORS: readonly ["not", "-", "exists", "not exists"];
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "not", "-", "exists", "not exists"];
-export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
-export declare type ArithmeticOperator = typeof ARITHMETIC_OPERATORS[number];
-export declare type BinaryOperator = typeof BINARY_OPERATORS[number];
-export declare type UnaryOperator = typeof UNARY_OPERATORS[number];
-export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];
-export declare type Operator = typeof OPERATORS[number];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists"];
+export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
+export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
+export type JSONOperator = (typeof JSON_OPERATORS)[number];
+export type JSONOperatorWith$ = JSONOperator | `${JSONOperator}$`;
+export type BinaryOperator = (typeof BINARY_OPERATORS)[number];
+export type UnaryOperator = (typeof UNARY_OPERATORS)[number];
+export type UnaryFilterOperator = (typeof UNARY_FILTER_OPERATORS)[number];
+export type Operator = (typeof OPERATORS)[number];
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';
     readonly operator: Operator;
@@ -26,3 +29,4 @@ export declare function isOperator(op: unknown): op is Operator;
 export declare function isBinaryOperator(op: unknown): op is BinaryOperator;
 export declare function isComparisonOperator(op: unknown): op is ComparisonOperator;
 export declare function isArithmeticOperator(op: unknown): op is ArithmeticOperator;
+export declare function isJSONOperator(op: unknown): op is JSONOperator;