kysely 0.27.1 → 0.27.3

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

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

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

@@ -21,6 +21,7 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly frontModifiers?: ReadonlyArray<OperationNode>;
     readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly nullsNotDistinct?: boolean;
+    readonly identity?: boolean;
 }
 /**
  * @internal

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

@@ -1,5 +1,7 @@
 import { OperationNode } from './operation-node.js';
-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';
+declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["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"];
+type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
+export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})`;
 export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
@@ -12,3 +14,5 @@ export declare const DataTypeNode: Readonly<{
     is(node: OperationNode): node is DataTypeNode;
     create(dataType: ColumnDataType): DataTypeNode;
 }>;
+export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
+export {};

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

@@ -1,7 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataTypeNode = void 0;
+exports.isColumnDataType = exports.DataTypeNode = void 0;
 const object_utils_js_1 = require("../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',
+];
+const COLUMN_DATA_TYPE_REGEX = [
+    /^varchar\(\d+\)$/,
+    /^char\(\d+\)$/,
+    /^decimal\(\d+, \d+\)$/,
+    /^numeric\(\d+, \d+\)$/,
+    /^binary\(\d+\)$/,
+    /^datetime\(\d+\)$/,
+    /^time\(\d+\)$/,
+    /^timez\(\d+\)$/,
+    /^timestamp\(\d+\)$/,
+    /^timestamptz\(\d+\)$/,
+];
 /**
  * @internal
  */
@@ -16,3 +60,13 @@ exports.DataTypeNode = (0, object_utils_js_1.freeze)({
         });
     },
 });
+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;
+}
+exports.isColumnDataType = isColumnDataType;

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

@@ -9,6 +9,7 @@ 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';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -20,6 +21,7 @@ export interface DeleteQueryNode extends OperationNode {
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
     readonly explain?: ExplainNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -28,6 +30,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/cjs/operation-node/delete-query-node.js

@@ -27,12 +27,24 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
                 : order_by_node_js_1.OrderByNode.create(items),
         });
     },
+    cloneWithoutOrderBy(deleteNode) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            orderBy: undefined,
+        });
+    },
     cloneWithLimit(deleteNode, limit) {
         return (0, object_utils_js_1.freeze)({
             ...deleteNode,
             limit,
         });
     },
+    cloneWithoutLimit(deleteNode) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            limit: undefined,
+        });
+    },
     cloneWithUsing(deleteNode, tables) {
         return (0, object_utils_js_1.freeze)({
             ...deleteNode,

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchNode = void 0;
+const value_node_js_1 = require("./value-node.js");
+/**
+ * @internal
+ */
+exports.FetchNode = {
+    is(node) {
+        return node.kind === 'FetchNode';
+    },
+    create(rowCount, modifier) {
+        return {
+            kind: 'FetchNode',
+            rowCount: value_node_js_1.ValueNode.create(rowCount),
+            modifier,
+        };
+    },
+};

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

@@ -5,11 +5,12 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-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 +21,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -27,5 +29,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/cjs/operation-node/insert-query-node.js

@@ -17,6 +17,11 @@ exports.InsertQueryNode = (0, object_utils_js_1.freeze)({
             replace,
         });
     },
+    createWithoutInto() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'InsertQueryNode',
+        });
+    },
     cloneWith(insertQuery, props) {
         return (0, object_utils_js_1.freeze)({
             ...insertQuery,

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 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/cjs/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/cjs/operation-node/matched-node.js

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

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

@@ -0,0 +1,25 @@
+import { AliasNode } from './alias-node.js';
+import { JoinNode } from './join-node.js';
+import { OperationNode } from './operation-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;
+}
+/**
+ * @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/cjs/operation-node/merge-query-node.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeQueryNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const when_node_js_1 = require("./when-node.js");
+/**
+ * @internal
+ */
+exports.MergeQueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'MergeQueryNode';
+    },
+    create(into, withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'MergeQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+        });
+    },
+    cloneWithUsing(mergeNode, using) {
+        return (0, object_utils_js_1.freeze)({
+            ...mergeNode,
+            using,
+        });
+    },
+    cloneWithWhen(mergeNode, when) {
+        return (0, object_utils_js_1.freeze)({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? (0, object_utils_js_1.freeze)([...mergeNode.whens, when])
+                : (0, object_utils_js_1.freeze)([when]),
+        });
+    },
+    cloneWithThen(mergeNode, then) {
+        return (0, object_utils_js_1.freeze)({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? (0, object_utils_js_1.freeze)([
+                    ...mergeNode.whens.slice(0, -1),
+                    when_node_js_1.WhenNode.cloneWithResult(mergeNode.whens[mergeNode.whens.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+});

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

@@ -85,7 +85,12 @@ 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';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -200,7 +205,12 @@ 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 transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -121,7 +121,12 @@ 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),
     });
     transformNode(node) {
         if (!node) {
@@ -159,6 +164,8 @@ 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) {
@@ -260,6 +267,7 @@ class OperationNodeTransformer {
             replace: node.replace,
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
+            top: this.transformNode(node.top),
         });
     }
     transformValues(node) {
@@ -280,6 +288,7 @@ class OperationNodeTransformer {
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
             explain: this.transformNode(node.explain),
+            top: this.transformNode(node.top),
         });
     }
     transformReturning(node) {
@@ -319,6 +328,7 @@ class OperationNodeTransformer {
             frontModifiers: this.transformNodeList(node.frontModifiers),
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
+            identity: node.identity,
         });
     }
     transformAddColumn(node) {
@@ -371,6 +381,8 @@ 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),
         });
     }
     transformColumnUpdate(node) {
@@ -774,6 +786,23 @@ class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
         });
     }
+    transformMergeQuery(node) {
+        return (0, require_all_props_js_1.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),
+        });
+    }
+    transformMatched(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'MatchedNode',
+            not: node.not,
+            bySource: node.bySource,
+        });
+    }
     transformAddIndex(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AddIndexNode',
@@ -784,6 +813,27 @@ class OperationNodeTransformer {
             ifNotExists: node.ifNotExists,
         });
     }
+    transformCast(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'CastNode',
+            expression: this.transformNode(node.expression),
+            dataType: this.transformNode(node.dataType),
+        });
+    }
+    transformFetch(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'FetchNode',
+            rowCount: this.transformNode(node.rowCount),
+            modifier: node.modifier,
+        });
+    }
+    transformTop(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'TopNode',
+            expression: node.expression,
+            modifiers: node.modifiers,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -85,7 +85,12 @@ 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';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -177,5 +182,10 @@ 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;
 }

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

@@ -94,7 +94,12 @@ 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),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/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';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -10,7 +10,9 @@ import { OperationNode } from './operation-node.js';
 import { ExplainNode } from './explain-node.js';
 import { ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
-export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
+import { MergeQueryNode } from './merge-query-node.js';
+import { TopNode } from './top-node.js';
+export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
 };
@@ -23,6 +25,9 @@ type HasReturning = {
 type HasExplain = {
     explain?: ExplainNode;
 };
+type HasTop = {
+    top?: TopNode;
+};
 /**
  * @internal
  */
@@ -31,7 +36,9 @@ export declare const QueryNode: Readonly<{
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
     cloneWithJoin<T_1 extends HasJoins>(node: T_1, join: JoinNode): T_1;
     cloneWithReturning<T_2 extends HasReturning>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
-    cloneWithoutWhere<T_3 extends HasWhere>(node: T_3): T_3;
-    cloneWithExplain<T_4 extends HasExplain>(node: T_4, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_4;
+    cloneWithoutReturning<T_3 extends HasReturning>(node: T_3): T_3;
+    cloneWithoutWhere<T_4 extends HasWhere>(node: T_4): T_4;
+    cloneWithExplain<T_5 extends HasExplain>(node: T_5, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_5;
+    cloneWithTop<T_6 extends HasTop>(node: T_6, top: TopNode): T_6;
 }>;
 export {};

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

@@ -9,6 +9,7 @@ const where_node_js_1 = require("./where-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const returning_node_js_1 = require("./returning-node.js");
 const explain_node_js_1 = require("./explain-node.js");
+const merge_query_node_js_1 = require("./merge-query-node.js");
 /**
  * @internal
  */
@@ -17,7 +18,8 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
         return (select_query_node_js_1.SelectQueryNode.is(node) ||
             insert_query_node_js_1.InsertQueryNode.is(node) ||
             update_query_node_js_1.UpdateQueryNode.is(node) ||
-            delete_query_node_js_1.DeleteQueryNode.is(node));
+            delete_query_node_js_1.DeleteQueryNode.is(node) ||
+            merge_query_node_js_1.MergeQueryNode.is(node));
     },
     cloneWithWhere(node, operation) {
         return (0, object_utils_js_1.freeze)({
@@ -41,6 +43,12 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
                 : returning_node_js_1.ReturningNode.create(selections),
         });
     },
+    cloneWithoutReturning(node) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            returning: undefined,
+        });
+    },
     cloneWithoutWhere(node) {
         return (0, object_utils_js_1.freeze)({
             ...node,
@@ -53,4 +61,10 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             explain: explain_node_js_1.ExplainNode.create(format, options?.toOperationNode()),
         });
     },
+    cloneWithTop(node, top) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            top,
+        });
+    },
 });

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

@@ -14,6 +14,8 @@ import { WithNode } from './with-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { ExplainNode } from './explain-node.js';
 import { SetOperationNode } from './set-operation-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from?: FromNode;
@@ -31,6 +33,8 @@ export interface SelectQueryNode extends OperationNode {
     readonly having?: HavingNode;
     readonly explain?: ExplainNode;
     readonly setOperations?: ReadonlyArray<SetOperationNode>;
+    readonly fetch?: FetchNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -47,6 +51,7 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
+    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;