kysely 0.27.2 → 0.27.4

package/dist/esm/operation-node/data-type-node.js

@@ -1,5 +1,51 @@
 /// <reference types="./data-type-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+const SIMPLE_COLUMN_DATA_TYPES = [
+    'varchar',
+    'char',
+    'text',
+    'integer',
+    'int2',
+    'int4',
+    'int8',
+    'smallint',
+    'bigint',
+    'boolean',
+    'real',
+    'double precision',
+    'float4',
+    'float8',
+    'decimal',
+    'numeric',
+    'binary',
+    'bytea',
+    'date',
+    'datetime',
+    'time',
+    'timetz',
+    'timestamp',
+    'timestamptz',
+    'serial',
+    'bigserial',
+    'uuid',
+    'json',
+    'jsonb',
+    'blob',
+    'varbinary',
+];
+const COLUMN_DATA_TYPE_REGEX = [
+    /^varchar\(\d+\)$/,
+    /^char\(\d+\)$/,
+    /^decimal\(\d+, \d+\)$/,
+    /^numeric\(\d+, \d+\)$/,
+    /^binary\(\d+\)$/,
+    /^datetime\(\d+\)$/,
+    /^time\(\d+\)$/,
+    /^timetz\(\d+\)$/,
+    /^timestamp\(\d+\)$/,
+    /^timestamptz\(\d+\)$/,
+    /^varbinary\(\d+\)$/,
+];
 /**
  * @internal
  */
@@ -14,3 +60,12 @@ export const DataTypeNode = freeze({
         });
     },
 });
+export function isColumnDataType(dataType) {
+    if (SIMPLE_COLUMN_DATA_TYPES.includes(dataType)) {
+        return true;
+    }
+    if (COLUMN_DATA_TYPE_REGEX.some((r) => r.test(dataType))) {
+        return true;
+    }
+    return false;
+}

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

@@ -9,6 +9,8 @@ import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { ExplainNode } from './explain-node.js';
 import { UsingNode } from './using-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -20,6 +22,8 @@ export interface DeleteQueryNode extends OperationNode {
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
     readonly explain?: ExplainNode;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal
@@ -28,6 +32,8 @@ export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItems(deleteNode: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): DeleteQueryNode;
+    cloneWithoutOrderBy(deleteNode: DeleteQueryNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
+    cloneWithoutLimit(deleteNode: DeleteQueryNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

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

@@ -25,12 +25,24 @@ export const DeleteQueryNode = freeze({
                 : OrderByNode.create(items),
         });
     },
+    cloneWithoutOrderBy(deleteNode) {
+        return freeze({
+            ...deleteNode,
+            orderBy: undefined,
+        });
+    },
     cloneWithLimit(deleteNode, limit) {
         return freeze({
             ...deleteNode,
             limit,
         });
     },
+    cloneWithoutLimit(deleteNode) {
+        return freeze({
+            ...deleteNode,
+            limit: undefined,
+        });
+    },
     cloneWithUsing(deleteNode, tables) {
         return freeze({
             ...deleteNode,

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

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+import { ValueNode } from './value-node.js';
+export type FetchModifier = 'only' | 'with ties';
+export interface FetchNode extends OperationNode {
+    readonly kind: 'FetchNode';
+    readonly rowCount: ValueNode;
+    readonly modifier: FetchModifier;
+}
+/**
+ * @internal
+ */
+export declare const FetchNode: {
+    is(node: OperationNode): node is FetchNode;
+    create(rowCount: number | bigint, modifier: FetchModifier): FetchNode;
+};

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

@@ -0,0 +1,17 @@
+/// <reference types="./fetch-node.d.ts" />
+import { ValueNode } from './value-node.js';
+/**
+ * @internal
+ */
+export const FetchNode = {
+    is(node) {
+        return node.kind === 'FetchNode';
+    },
+    create(rowCount, modifier) {
+        return {
+            kind: 'FetchNode',
+            rowCount: ValueNode.create(rowCount),
+            modifier,
+        };
+    },
+};

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

@@ -19,10 +19,10 @@ export declare const ForeignKeyConstraintNode: Readonly<{
     is(node: OperationNode): node is ForeignKeyConstraintNode;
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
     cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
-        name?: IdentifierNode | undefined;
-        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
-        onUpdate?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
-        kind: 'ForeignKeyConstraintNode';
+        name?: IdentifierNode;
+        onDelete?: OnModifyForeignAction;
+        onUpdate?: OnModifyForeignAction;
+        kind: "ForeignKeyConstraintNode";
         columns: ReadonlyArray<ColumnNode>;
         references: ReferencesNode;
     }>;

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

@@ -9,5 +9,5 @@ export interface HavingNode extends OperationNode {
 export declare const HavingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
     create(filter: OperationNode): HavingNode;
-    cloneWithOperation(havingNode: HavingNode, operator: 'And' | 'Or', operation: OperationNode): HavingNode;
+    cloneWithOperation(havingNode: HavingNode, operator: "And" | "Or", operation: OperationNode): HavingNode;
 }>;

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

@@ -3,13 +3,15 @@ import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
+import { OutputNode } from './output-node.js';
 import { ReturningNode } from './returning-node.js';
 import { TableNode } from './table-node.js';
+import { TopNode } from './top-node.js';
 import { WithNode } from './with-node.js';
 export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
-    readonly into: TableNode;
+    readonly into?: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly values?: OperationNode;
     readonly returning?: ReturningNode;
@@ -20,6 +22,8 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal
@@ -27,5 +31,6 @@ export interface InsertQueryNode extends OperationNode {
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
     create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
+    createWithoutInto(): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

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

@@ -15,6 +15,11 @@ export const InsertQueryNode = freeze({
             replace,
         });
     },
+    createWithoutInto() {
+        return freeze({
+            kind: 'InsertQueryNode',
+        });
+    },
     cloneWith(insertQuery, props) {
         return freeze({
             ...insertQuery,

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 type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
+export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'Using';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface MatchedNode extends OperationNode {
+    readonly kind: 'MatchedNode';
+    readonly not: boolean;
+    readonly bySource: boolean;
+}
+/**
+ * @internal
+ */
+export declare const MatchedNode: Readonly<{
+    is(node: OperationNode): node is MatchedNode;
+    create(not: boolean, bySource?: boolean): MatchedNode;
+}>;

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

@@ -0,0 +1,17 @@
+/// <reference types="./matched-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const MatchedNode = freeze({
+    is(node) {
+        return node.kind === 'MatchedNode';
+    },
+    create(not, bySource = false) {
+        return freeze({
+            kind: 'MatchedNode',
+            not,
+            bySource,
+        });
+    },
+});

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

@@ -0,0 +1,27 @@
+import { AliasNode } from './alias-node.js';
+import { JoinNode } from './join-node.js';
+import { OperationNode } from './operation-node.js';
+import { OutputNode } from './output-node.js';
+import { TableNode } from './table-node.js';
+import { TopNode } from './top-node.js';
+import { WhenNode } from './when-node.js';
+import { WithNode } from './with-node.js';
+export interface MergeQueryNode extends OperationNode {
+    readonly kind: 'MergeQueryNode';
+    readonly into: TableNode | AliasNode;
+    readonly using?: JoinNode;
+    readonly whens?: ReadonlyArray<WhenNode>;
+    readonly with?: WithNode;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
+}
+/**
+ * @internal
+ */
+export declare const MergeQueryNode: Readonly<{
+    is(node: OperationNode): node is MergeQueryNode;
+    create(into: TableNode | AliasNode, withNode?: WithNode): MergeQueryNode;
+    cloneWithUsing(mergeNode: MergeQueryNode, using: JoinNode): MergeQueryNode;
+    cloneWithWhen(mergeNode: MergeQueryNode, when: WhenNode): MergeQueryNode;
+    cloneWithThen(mergeNode: MergeQueryNode, then: OperationNode): MergeQueryNode;
+}>;

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

@@ -0,0 +1,43 @@
+/// <reference types="./merge-query-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhenNode } from './when-node.js';
+/**
+ * @internal
+ */
+export const MergeQueryNode = freeze({
+    is(node) {
+        return node.kind === 'MergeQueryNode';
+    },
+    create(into, withNode) {
+        return freeze({
+            kind: 'MergeQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+        });
+    },
+    cloneWithUsing(mergeNode, using) {
+        return freeze({
+            ...mergeNode,
+            using,
+        });
+    },
+    cloneWithWhen(mergeNode, when) {
+        return freeze({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? freeze([...mergeNode.whens, when])
+                : freeze([when]),
+        });
+    },
+    cloneWithThen(mergeNode, then) {
+        return freeze({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? freeze([
+                    ...mergeNode.whens.slice(0, -1),
+                    WhenNode.cloneWithResult(mergeNode.whens[mergeNode.whens.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+});

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

@@ -9,5 +9,5 @@ export interface OnNode extends OperationNode {
 export declare const OnNode: Readonly<{
     is(node: OperationNode): node is OnNode;
     create(filter: OperationNode): OnNode;
-    cloneWithOperation(onNode: OnNode, operator: 'And' | 'Or', operation: OperationNode): OnNode;
+    cloneWithOperation(onNode: OnNode, operator: "And" | "Or", operation: OperationNode): OnNode;
 }>;

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

@@ -85,7 +85,13 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { MatchedNode } from './matched-node.js';
 import { AddIndexNode } from './add-index-node.js';
+import { CastNode } from './cast-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -200,7 +206,13 @@ export declare class OperationNodeTransformer {
     protected transformJSONPathLeg(node: JSONPathLegNode): JSONPathLegNode;
     protected transformJSONOperatorChain(node: JSONOperatorChainNode): JSONOperatorChainNode;
     protected transformTuple(node: TupleNode): TupleNode;
+    protected transformMergeQuery(node: MergeQueryNode): MergeQueryNode;
+    protected transformMatched(node: MatchedNode): MatchedNode;
     protected transformAddIndex(node: AddIndexNode): AddIndexNode;
+    protected transformCast(node: CastNode): CastNode;
+    protected transformFetch(node: FetchNode): FetchNode;
+    protected transformTop(node: TopNode): TopNode;
+    protected transformOutput(node: OutputNode): OutputNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -119,7 +119,13 @@ export class OperationNodeTransformer {
         JSONPathLegNode: this.transformJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
         TupleNode: this.transformTuple.bind(this),
+        MergeQueryNode: this.transformMergeQuery.bind(this),
+        MatchedNode: this.transformMatched.bind(this),
         AddIndexNode: this.transformAddIndex.bind(this),
+        CastNode: this.transformCast.bind(this),
+        FetchNode: this.transformFetch.bind(this),
+        TopNode: this.transformTop.bind(this),
+        OutputNode: this.transformOutput.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -157,6 +163,8 @@ export class OperationNodeTransformer {
             having: this.transformNode(node.having),
             explain: this.transformNode(node.explain),
             setOperations: this.transformNodeList(node.setOperations),
+            fetch: this.transformNode(node.fetch),
+            top: this.transformNode(node.top),
         });
     }
     transformSelection(node) {
@@ -258,6 +266,8 @@ export class OperationNodeTransformer {
             replace: node.replace,
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformValues(node) {
@@ -278,6 +288,8 @@ export class OperationNodeTransformer {
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
             explain: this.transformNode(node.explain),
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformReturning(node) {
@@ -317,6 +329,8 @@ export class OperationNodeTransformer {
             frontModifiers: this.transformNodeList(node.frontModifiers),
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
+            identity: node.identity,
+            ifNotExists: node.ifNotExists,
         });
     }
     transformAddColumn(node) {
@@ -369,6 +383,9 @@ export class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
             explain: this.transformNode(node.explain),
+            limit: this.transformNode(node.limit),
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformColumnUpdate(node) {
@@ -772,6 +789,24 @@ export class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
         });
     }
+    transformMergeQuery(node) {
+        return requireAllProps({
+            kind: 'MergeQueryNode',
+            into: this.transformNode(node.into),
+            using: this.transformNode(node.using),
+            whens: this.transformNodeList(node.whens),
+            with: this.transformNode(node.with),
+            top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
+        });
+    }
+    transformMatched(node) {
+        return requireAllProps({
+            kind: 'MatchedNode',
+            not: node.not,
+            bySource: node.bySource,
+        });
+    }
     transformAddIndex(node) {
         return requireAllProps({
             kind: 'AddIndexNode',
@@ -782,6 +817,33 @@ export class OperationNodeTransformer {
             ifNotExists: node.ifNotExists,
         });
     }
+    transformCast(node) {
+        return requireAllProps({
+            kind: 'CastNode',
+            expression: this.transformNode(node.expression),
+            dataType: this.transformNode(node.dataType),
+        });
+    }
+    transformFetch(node) {
+        return requireAllProps({
+            kind: 'FetchNode',
+            rowCount: this.transformNode(node.rowCount),
+            modifier: node.modifier,
+        });
+    }
+    transformTop(node) {
+        return requireAllProps({
+            kind: 'TopNode',
+            expression: node.expression,
+            modifiers: node.modifiers,
+        });
+    }
+    transformOutput(node) {
+        return requireAllProps({
+            kind: 'OutputNode',
+            selections: this.transformNodeList(node.selections),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -85,7 +85,13 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { MatchedNode } from './matched-node.js';
 import { AddIndexNode } from './add-index-node.js';
+import { CastNode } from './cast-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -177,5 +183,11 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
     protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
     protected abstract visitTuple(node: TupleNode): void;
+    protected abstract visitMergeQuery(node: MergeQueryNode): void;
+    protected abstract visitMatched(node: MatchedNode): void;
     protected abstract visitAddIndex(node: AddIndexNode): void;
+    protected abstract visitCast(node: CastNode): void;
+    protected abstract visitFetch(node: FetchNode): void;
+    protected abstract visitTop(node: TopNode): void;
+    protected abstract visitOutput(node: OutputNode): void;
 }

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

@@ -92,7 +92,13 @@ export class OperationNodeVisitor {
         JSONPathLegNode: this.visitJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
         TupleNode: this.visitTuple.bind(this),
+        MergeQueryNode: this.visitMergeQuery.bind(this),
+        MatchedNode: this.visitMatched.bind(this),
         AddIndexNode: this.visitAddIndex.bind(this),
+        CastNode: this.visitCast.bind(this),
+        FetchNode: this.visitFetch.bind(this),
+        TopNode: this.visitTop.bind(this),
+        OutputNode: this.visitOutput.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-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' | 'TupleNode' | 'AddIndexNode';
+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' | 'TupleNode' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode' | 'OutputNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,11 +1,11 @@
 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", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
 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", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 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", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "^@", "&&", "?", "?&", "?|", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
 export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
 export type JSONOperator = (typeof JSON_OPERATORS)[number];

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

@@ -20,9 +20,11 @@ export const COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '^@',
     '&&',
     '?',
     '?&',
+    '?|',
     '!<',
     '!>',
     '<=>',

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface OutputNode extends OperationNode {
+    readonly kind: 'OutputNode';
+    readonly selections: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const OutputNode: Readonly<{
+    is(node: OperationNode): node is OutputNode;
+    create(selections: ReadonlyArray<OperationNode>): OutputNode;
+    cloneWithSelections(output: OutputNode, selections: ReadonlyArray<OperationNode>): OutputNode;
+}>;

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

@@ -0,0 +1,24 @@
+/// <reference types="./output-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const OutputNode = freeze({
+    is(node) {
+        return node.kind === 'OutputNode';
+    },
+    create(selections) {
+        return freeze({
+            kind: 'OutputNode',
+            selections: freeze(selections),
+        });
+    },
+    cloneWithSelections(output, selections) {
+        return freeze({
+            ...output,
+            selections: output.selections
+                ? freeze([...output.selections, ...selections])
+                : freeze(selections),
+        });
+    },
+});