kysely 0.8.1 → 0.9.3

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

@@ -24,14 +24,16 @@ export const JoinNode = freeze({
             on,
         });
     },
-    cloneWithOn(joinNode, op, on) {
+    cloneWithOn(joinNode, on) {
         return freeze({
             ...joinNode,
-            on: joinNode.on
-                ? op === 'And'
-                    ? AndNode.create(joinNode.on, on)
-                    : OrNode.create(joinNode.on, on)
-                : on,
+            on: joinNode.on ? AndNode.create(joinNode.on, on) : on,
+        });
+    },
+    cloneWithOrOn(joinNode, on) {
+        return freeze({
+            ...joinNode,
+            on: joinNode.on ? OrNode.create(joinNode.on, on) : on,
         });
     },
 });

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

@@ -2,4 +2,4 @@ import { OperationNode } from './operation-node.js';
 export interface OperationNodeSource {
     toOperationNode(): OperationNode;
 }
-export declare function isOperationNodeSource(obj: any): obj is OperationNodeSource;
+export declare function isOperationNodeSource(obj: unknown): obj is OperationNodeSource;

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

@@ -57,6 +57,7 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import { UnionNode } from './union-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -129,6 +130,7 @@ export declare class OperationNodeTransformer {
     protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): PrimaryKeyConstraintNode;
     protected transformUniqueConstraint(node: UniqueConstraintNode): UniqueConstraintNode;
     protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode): ForeignKeyConstraintNode;
+    protected transformUnion(node: UnionNode): UnionNode;
     protected transformReferences(node: ReferencesNode): ReferencesNode;
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;

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

@@ -89,6 +89,7 @@ export class OperationNodeTransformer {
         AddConstraintNode: this.transformAddConstraint.bind(this),
         DropConstraintNode: this.transformDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
+        UnionNode: this.transformUnion.bind(this),
     };
     transformNode = (node) => {
         if (!node) {
@@ -121,6 +122,7 @@ export class OperationNodeTransformer {
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
+            union: this.transformNodeList(node.union),
         };
     }
     transformSelection(node) {
@@ -400,6 +402,13 @@ export class OperationNodeTransformer {
             onUpdate: node.onUpdate,
         };
     }
+    transformUnion(node) {
+        return {
+            kind: 'UnionNode',
+            union: this.transformNode(node.union),
+            all: node.all,
+        };
+    }
     transformReferences(node) {
         return {
             kind: 'ReferencesNode',
@@ -453,11 +462,12 @@ export class OperationNodeTransformer {
             kind: 'AlterTableNode',
             table: this.transformNode(node.table),
             renameTo: this.transformNode(node.renameTo),
-            renameColumn: this.transformNode(node.renameColumn),
             setSchema: this.transformNode(node.setSchema),
+            renameColumn: this.transformNode(node.renameColumn),
             addColumn: this.transformNode(node.addColumn),
             dropColumn: this.transformNode(node.dropColumn),
             alterColumn: this.transformNode(node.alterColumn),
+            modifyColumn: this.transformNode(node.modifyColumn),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
         };

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

@@ -57,66 +57,68 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
-export declare class OperationNodeVisitor {
+import { UnionNode } from './union-node.js';
+export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
     protected readonly visitNode: (node: OperationNode) => void;
-    protected visitSelectQuery(node: SelectQueryNode): void;
-    protected visitSelection(node: SelectionNode): void;
-    protected visitColumn(node: ColumnNode): void;
-    protected visitAlias(node: AliasNode): void;
-    protected visitTable(node: TableNode): void;
-    protected visitFrom(node: FromNode): void;
-    protected visitReference(node: ReferenceNode): void;
-    protected visitFilter(node: FilterNode): void;
-    protected visitAnd(node: AndNode): void;
-    protected visitOr(node: OrNode): void;
-    protected visitValueList(node: ValueListNode): void;
-    protected visitParens(node: ParensNode): void;
-    protected visitJoin(node: JoinNode): void;
-    protected visitRaw(node: RawNode): void;
-    protected visitWhere(node: WhereNode): void;
-    protected visitInsertQuery(node: InsertQueryNode): void;
-    protected visitDeleteQuery(node: DeleteQueryNode): void;
-    protected visitReturning(node: ReturningNode): void;
-    protected visitCreateTable(node: CreateTableNode): void;
-    protected visitAddColumn(node: AddColumnNode): void;
-    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
-    protected visitDropTable(node: DropTableNode): void;
-    protected visitOrderBy(node: OrderByNode): void;
-    protected visitOrderByItem(node: OrderByItemNode): void;
-    protected visitGroupBy(node: GroupByNode): void;
-    protected visitGroupByItem(node: GroupByItemNode): void;
-    protected visitUpdateQuery(node: UpdateQueryNode): void;
-    protected visitColumnUpdate(node: ColumnUpdateNode): void;
-    protected visitLimit(node: LimitNode): void;
-    protected visitOffset(node: OffsetNode): void;
-    protected visitOnConflict(node: OnConflictNode): void;
-    protected visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
-    protected visitCreateIndex(node: CreateIndexNode): void;
-    protected visitList(node: ListNode): void;
-    protected visitDropIndex(node: DropIndexNode): void;
-    protected visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
-    protected visitUniqueConstraint(node: UniqueConstraintNode): void;
-    protected visitReferences(node: ReferencesNode): void;
-    protected visitCheckConstraint(node: CheckConstraintNode): void;
-    protected visitWith(node: WithNode): void;
-    protected visitCommonTableExpression(node: CommonTableExpressionNode): void;
-    protected visitHaving(node: HavingNode): void;
-    protected visitCreateSchema(node: CreateSchemaNode): void;
-    protected visitDropSchema(node: DropSchemaNode): void;
-    protected visitAlterTable(node: AlterTableNode): void;
-    protected visitDropColumn(node: DropColumnNode): void;
-    protected visitRenameColumn(node: RenameColumnNode): void;
-    protected visitAlterColumn(node: AlterColumnNode): void;
-    protected visitModifyColumn(node: ModifyColumnNode): void;
-    protected visitAddConstraint(node: AddConstraintNode): void;
-    protected visitDropConstraint(node: DropConstraintNode): void;
-    protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
-    protected visitDataType(node: DataTypeNode): void;
-    protected visitSelectAll(_: SelectAllNode): void;
-    protected visitIdentifier(_: IdentifierNode): void;
-    protected visitValue(_: ValueNode): void;
-    protected visitPrimitiveValueList(_: PrimitiveValueListNode): void;
-    protected visitOperator(node: OperatorNode): void;
+    protected abstract visitSelectQuery(node: SelectQueryNode): void;
+    protected abstract visitSelection(node: SelectionNode): void;
+    protected abstract visitColumn(node: ColumnNode): void;
+    protected abstract visitAlias(node: AliasNode): void;
+    protected abstract visitTable(node: TableNode): void;
+    protected abstract visitFrom(node: FromNode): void;
+    protected abstract visitReference(node: ReferenceNode): void;
+    protected abstract visitFilter(node: FilterNode): void;
+    protected abstract visitAnd(node: AndNode): void;
+    protected abstract visitOr(node: OrNode): void;
+    protected abstract visitValueList(node: ValueListNode): void;
+    protected abstract visitParens(node: ParensNode): void;
+    protected abstract visitJoin(node: JoinNode): void;
+    protected abstract visitRaw(node: RawNode): void;
+    protected abstract visitWhere(node: WhereNode): void;
+    protected abstract visitInsertQuery(node: InsertQueryNode): void;
+    protected abstract visitDeleteQuery(node: DeleteQueryNode): void;
+    protected abstract visitReturning(node: ReturningNode): void;
+    protected abstract visitCreateTable(node: CreateTableNode): void;
+    protected abstract visitAddColumn(node: AddColumnNode): void;
+    protected abstract visitColumnDefinition(node: ColumnDefinitionNode): void;
+    protected abstract visitDropTable(node: DropTableNode): void;
+    protected abstract visitOrderBy(node: OrderByNode): void;
+    protected abstract visitOrderByItem(node: OrderByItemNode): void;
+    protected abstract visitGroupBy(node: GroupByNode): void;
+    protected abstract visitGroupByItem(node: GroupByItemNode): void;
+    protected abstract visitUpdateQuery(node: UpdateQueryNode): void;
+    protected abstract visitColumnUpdate(node: ColumnUpdateNode): void;
+    protected abstract visitLimit(node: LimitNode): void;
+    protected abstract visitOffset(node: OffsetNode): void;
+    protected abstract visitOnConflict(node: OnConflictNode): void;
+    protected abstract visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
+    protected abstract visitCreateIndex(node: CreateIndexNode): void;
+    protected abstract visitDropIndex(node: DropIndexNode): void;
+    protected abstract visitList(node: ListNode): void;
+    protected abstract visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
+    protected abstract visitUniqueConstraint(node: UniqueConstraintNode): void;
+    protected abstract visitReferences(node: ReferencesNode): void;
+    protected abstract visitCheckConstraint(node: CheckConstraintNode): void;
+    protected abstract visitWith(node: WithNode): void;
+    protected abstract visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected abstract visitHaving(node: HavingNode): void;
+    protected abstract visitCreateSchema(node: CreateSchemaNode): void;
+    protected abstract visitDropSchema(node: DropSchemaNode): void;
+    protected abstract visitAlterTable(node: AlterTableNode): void;
+    protected abstract visitDropColumn(node: DropColumnNode): void;
+    protected abstract visitRenameColumn(node: RenameColumnNode): void;
+    protected abstract visitAlterColumn(node: AlterColumnNode): void;
+    protected abstract visitModifyColumn(node: ModifyColumnNode): void;
+    protected abstract visitAddConstraint(node: AddConstraintNode): void;
+    protected abstract visitDropConstraint(node: DropConstraintNode): void;
+    protected abstract visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
+    protected abstract visitUnion(node: UnionNode): void;
+    protected abstract visitDataType(node: DataTypeNode): void;
+    protected abstract visitSelectAll(_: SelectAllNode): void;
+    protected abstract visitIdentifier(_: IdentifierNode): void;
+    protected abstract visitValue(_: ValueNode): void;
+    protected abstract visitPrimitiveValueList(_: PrimitiveValueListNode): void;
+    protected abstract visitOperator(node: OperatorNode): void;
 }

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

@@ -59,326 +59,11 @@ export class OperationNodeVisitor {
         AddConstraintNode: this.visitAddConstraint.bind(this),
         DropConstraintNode: this.visitDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
+        UnionNode: this.visitUnion.bind(this),
     };
     visitNode = (node) => {
         this.nodeStack.push(node);
         this.#visitors[node.kind](node);
         this.nodeStack.pop();
     };
-    visitSelectQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        if (node.distinctOnSelections) {
-            node.distinctOnSelections.forEach(this.visitNode);
-        }
-        if (node.selections) {
-            node.selections.forEach(this.visitNode);
-        }
-        this.visitNode(node.from);
-        if (node.joins) {
-            node.joins.forEach(this.visitNode);
-        }
-        if (node.where) {
-            this.visitNode(node.where);
-        }
-        if (node.groupBy) {
-            this.visitNode(node.groupBy);
-        }
-        if (node.having) {
-            this.visitNode(node.having);
-        }
-        if (node.orderBy) {
-            this.visitNode(node.orderBy);
-        }
-        if (node.limit) {
-            this.visitNode(node.limit);
-        }
-        if (node.offset) {
-            this.visitNode(node.offset);
-        }
-    }
-    visitSelection(node) {
-        this.visitNode(node.selection);
-    }
-    visitColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitAlias(node) {
-        this.visitNode(node.node);
-    }
-    visitTable(node) {
-        if (node.schema) {
-            this.visitNode(node.schema);
-        }
-        this.visitNode(node.table);
-    }
-    visitFrom(node) {
-        node.froms.forEach(this.visitNode);
-    }
-    visitReference(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.table);
-    }
-    visitFilter(node) {
-        if (node.left) {
-            this.visitNode(node.left);
-        }
-        this.visitNode(node.op);
-        this.visitNode(node.right);
-    }
-    visitAnd(node) {
-        this.visitNode(node.left);
-        this.visitNode(node.right);
-    }
-    visitOr(node) {
-        this.visitNode(node.left);
-        this.visitNode(node.right);
-    }
-    visitValueList(node) {
-        node.values.forEach(this.visitNode);
-    }
-    visitParens(node) {
-        this.visitNode(node.node);
-    }
-    visitJoin(node) {
-        this.visitNode(node.table);
-        if (node.on) {
-            this.visitNode(node.on);
-        }
-    }
-    visitRaw(node) {
-        node.params.forEach(this.visitNode);
-    }
-    visitWhere(node) {
-        this.visitNode(node.where);
-    }
-    visitInsertQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        this.visitNode(node.into);
-        if (node.columns) {
-            node.columns.forEach(this.visitNode);
-        }
-        if (node.values) {
-            node.values.forEach(this.visitNode);
-        }
-        if (node.returning) {
-            this.visitNode(node.returning);
-        }
-    }
-    visitDeleteQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        this.visitNode(node.from);
-        if (node.joins) {
-            node.joins.forEach(this.visitNode);
-        }
-        if (node.where) {
-            this.visitNode(node.where);
-        }
-        if (node.returning) {
-            this.visitNode(node.returning);
-        }
-    }
-    visitReturning(node) {
-        node.selections.forEach(this.visitNode);
-    }
-    visitCreateTable(node) {
-        this.visitNode(node.table);
-        node.columns.forEach(this.visitNode);
-        if (node.constraints) {
-            node.constraints.forEach(this.visitNode);
-        }
-    }
-    visitAddColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitColumnDefinition(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.dataType);
-        if (node.defaultTo) {
-            this.visitNode(node.defaultTo);
-        }
-        if (node.references) {
-            this.visitNode(node.references);
-        }
-        if (node.check) {
-            this.visitNode(node.check);
-        }
-    }
-    visitDropTable(node) {
-        this.visitNode(node.table);
-    }
-    visitOrderBy(node) {
-        node.items.forEach(this.visitNode);
-    }
-    visitOrderByItem(node) {
-        this.visitNode(node.orderBy);
-    }
-    visitGroupBy(node) {
-        node.items.forEach(this.visitNode);
-    }
-    visitGroupByItem(node) {
-        this.visitNode(node.groupBy);
-    }
-    visitUpdateQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        this.visitNode(node.table);
-        if (node.updates) {
-            node.updates.forEach(this.visitNode);
-        }
-        if (node.joins) {
-            node.joins.forEach(this.visitNode);
-        }
-        if (node.where) {
-            this.visitNode(node.where);
-        }
-        if (node.returning) {
-            this.visitNode(node.returning);
-        }
-    }
-    visitColumnUpdate(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.value);
-    }
-    visitLimit(node) {
-        this.visitNode(node.limit);
-    }
-    visitOffset(node) {
-        this.visitNode(node.offset);
-    }
-    visitOnConflict(node) {
-        if (node.columns) {
-            node.columns.forEach(this.visitNode);
-        }
-        if (node.constraint) {
-            this.visitNode(node.constraint);
-        }
-        if (node.updates) {
-            node.updates.forEach(this.visitNode);
-        }
-    }
-    visitOnDuplicateKey(node) {
-        node.updates.forEach(this.visitNode);
-    }
-    visitCreateIndex(node) {
-        this.visitNode(node.name);
-        if (node.table) {
-            this.visitNode(node.table);
-        }
-        if (node.using) {
-            this.visitNode(node.using);
-        }
-        if (node.expression) {
-            this.visitNode(node.expression);
-        }
-    }
-    visitList(node) {
-        node.items.forEach(this.visitNode);
-    }
-    visitDropIndex(node) {
-        this.visitNode(node.name);
-        if (node.table) {
-            this.visitNode(node.table);
-        }
-    }
-    visitPrimaryKeyConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        node.columns.forEach(this.visitNode);
-    }
-    visitUniqueConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        node.columns.forEach(this.visitNode);
-    }
-    visitReferences(node) {
-        node.columns.forEach(this.visitNode);
-        this.visitNode(node.table);
-    }
-    visitCheckConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        this.visitNode(node.expression);
-    }
-    visitWith(node) {
-        node.expressions.forEach(this.visitNode);
-    }
-    visitCommonTableExpression(node) {
-        this.visitNode(node.name);
-        this.visitNode(node.expression);
-    }
-    visitHaving(node) {
-        this.visitNode(node.having);
-    }
-    visitCreateSchema(node) {
-        this.visitNode(node.schema);
-    }
-    visitDropSchema(node) {
-        this.visitNode(node.schema);
-    }
-    visitAlterTable(node) {
-        this.visitNode(node.table);
-        if (node.renameTo) {
-            this.visitNode(node.renameTo);
-        }
-        if (node.renameColumn) {
-            this.visitNode(node.renameColumn);
-        }
-        if (node.setSchema) {
-            this.visitNode(node.setSchema);
-        }
-        if (node.addColumn) {
-            this.visitNode(node.addColumn);
-        }
-        if (node.dropColumn) {
-            this.visitNode(node.dropColumn);
-        }
-        if (node.alterColumn) {
-            this.visitNode(node.alterColumn);
-        }
-        if (node.modifyColumn) {
-            this.visitNode(node.modifyColumn);
-        }
-    }
-    visitDropColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitRenameColumn(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.renameTo);
-    }
-    visitAlterColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitModifyColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitAddConstraint(node) {
-        this.visitNode(node.constraint);
-    }
-    visitDropConstraint(node) {
-        this.visitNode(node.constraintName);
-    }
-    visitForeignKeyConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        node.columns.forEach(this.visitNode);
-        this.visitNode(node.references);
-    }
-    visitDataType(node) { }
-    visitSelectAll(_) { }
-    visitIdentifier(_) { }
-    visitValue(_) { }
-    visitPrimitiveValueList(_) { }
-    visitOperator(node) { }
 }

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/primitive-value-list-node.js

@@ -9,7 +9,7 @@ export const PrimitiveValueListNode = freeze({
     create(values) {
         return freeze({
             kind: 'PrimitiveValueListNode',
-            values: freeze(values),
+            values: freeze([...values]),
         });
     },
 });

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

@@ -16,7 +16,8 @@ export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     isMutating(node: OperationNode): node is MutatingQueryNode;
     isFilterable(node: OperationNode): node is FilterableQueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, op: 'And' | 'Or', filter: WhereChildNode): T;
-    cloneWithJoin<T_1 extends FilterableQueryNode>(node: T_1, join: JoinNode): T_1;
-    cloneWithReturning<T_2 extends MutatingQueryNode>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: WhereChildNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: WhereChildNode): T_1;
+    cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
+    cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

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

@@ -25,11 +25,19 @@ export const QueryNode = freeze({
             DeleteQueryNode.is(node) ||
             UpdateQueryNode.is(node));
     },
-    cloneWithWhere(node, op, filter) {
+    cloneWithWhere(node, filter) {
         return freeze({
             ...node,
             where: node.where
-                ? WhereNode.cloneWithFilter(node.where, op, filter)
+                ? WhereNode.cloneWithFilter(node.where, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOrWhere(node, filter) {
+        return freeze({
+            ...node,
+            where: node.where
+                ? WhereNode.cloneWithFilter(node.where, 'Or', filter)
                 : WhereNode.create(filter),
         });
     },

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

@@ -12,6 +12,7 @@ import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { UnionNode } from './union-node.js';
 export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
@@ -28,6 +29,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
     readonly having?: HavingNode;
+    readonly union?: ReadonlyArray<UnionNode>;
 }
 /**
  * @internal
@@ -42,6 +44,8 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, op: 'And' | 'Or', filter: HavingNodeChild): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
+    cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -69,11 +69,19 @@ export const SelectQueryNode = freeze({
             offset,
         });
     },
-    cloneWithHaving(selectNode, op, filter) {
+    cloneWithHaving(selectNode, filter) {
         return freeze({
             ...selectNode,
             having: selectNode.having
-                ? HavingNode.cloneWithFilter(selectNode.having, op, filter)
+                ? HavingNode.cloneWithFilter(selectNode.having, 'And', filter)
+                : HavingNode.create(filter),
+        });
+    },
+    cloneWithOrHaving(selectNode, filter) {
+        return freeze({
+            ...selectNode,
+            having: selectNode.having
+                ? HavingNode.cloneWithFilter(selectNode.having, 'Or', filter)
                 : HavingNode.create(filter),
         });
     },
@@ -83,4 +91,12 @@ export const SelectQueryNode = freeze({
             isDistinct: true,
         });
     },
+    cloneWithUnion(selectNode, union) {
+        return freeze({
+            ...selectNode,
+            union: selectNode.union
+                ? freeze([...selectNode.union, union])
+                : freeze([union]),
+        });
+    },
 });