kysely 0.27.3 → 0.27.5

package/dist/cjs/migration/migrator.js

@@ -20,16 +20,29 @@ exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true }
  * other way.
  *
  * ```ts
- * import { promises as fs } from 'fs'
- * import path from 'path'
+ * import { promises as fs } from 'node:fs'
+ * import path from 'node:path'
+ * import * as Sqlite from 'better-sqlite3'
+ * import {
+ *   FileMigrationProvider,
+ *   Kysely,
+ *   Migrator,
+ *   SqliteDialect
+ * } from 'kysely'
+ *
+ * const db = new Kysely<any>({
+ *   dialect: new SqliteDialect({
+ *     database: Sqlite(':memory:')
+ *   })
+ * })
  *
  * const migrator = new Migrator({
  *   db,
  *   provider: new FileMigrationProvider({
  *     fs,
- *     path,
  *     // Path to the folder that contains all your migrations.
- *     migrationFolder: 'some/path/to/migrations'
+ *     migrationFolder: 'some/path/to/migrations',
+ *     path,
  *   })
  * })
  * ```
@@ -78,19 +91,18 @@ class Migrator {
      * ### Examples
      *
      * ```ts
-     * const db = new Kysely<Database>({
-     *   dialect: new PostgresDialect({
-     *     host: 'localhost',
-     *     database: 'kysely_test',
-     *   }),
-     * })
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import * as Sqlite from 'better-sqlite3'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
      *
      * const migrator = new Migrator({
      *   db,
-     *   provider: new FileMigrationProvider(
-     *     // Path to the folder that contains all your migrations.
-     *     'some/path/to/migrations'
-     *   )
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
      * })
      *
      * const { error, results } = await migrator.migrateToLatest()
@@ -123,6 +135,20 @@ class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo('some_migration')
      * ```
      *
@@ -132,6 +158,20 @@ class Migrator {
      * you can use a special constant `NO_MIGRATIONS`:
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo(NO_MIGRATIONS)
      * ```
      */
@@ -170,6 +210,20 @@ class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateUp()
      * ```
      */
@@ -187,6 +241,20 @@ class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateDown()
      * ```
      */

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

@@ -1,11 +1,14 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
 import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: string;
     readonly aggregated: readonly OperationNode[];
     readonly distinct?: boolean;
+    readonly orderBy?: OrderByNode;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
@@ -16,6 +19,7 @@ export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
     create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;

package/dist/cjs/operation-node/aggregate-function-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateFunctionNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const where_node_js_1 = require("./where-node.js");
+const order_by_node_js_1 = require("./order-by-node.js");
 /**
  * @internal
  */
@@ -23,6 +24,14 @@ exports.AggregateFunctionNode = (0, object_utils_js_1.freeze)({
             distinct: true,
         });
     },
+    cloneWithOrderBy(aggregateFunctionNode, orderItems) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            orderBy: aggregateFunctionNode.orderBy
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(aggregateFunctionNode.orderBy, orderItems)
+                : order_by_node_js_1.OrderByNode.create(orderItems),
+        });
+    },
     cloneWithFilter(aggregateFunctionNode, filter) {
         return (0, object_utils_js_1.freeze)({
             ...aggregateFunctionNode,

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

@@ -17,5 +17,5 @@ export interface AlterColumnNode extends OperationNode {
  */
 export declare const AlterColumnNode: Readonly<{
     is(node: OperationNode): node is AlterColumnNode;
-    create<T extends "dataType" | "dataTypeExpression" | "setDefault" | "dropDefault" | "setNotNull" | "dropNotNull">(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): AlterColumnNode;
+    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): AlterColumnNode;
 }>;

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

@@ -15,5 +15,5 @@ export declare const CaseNode: Readonly<{
     create(value?: OperationNode): CaseNode;
     cloneWithWhen(caseNode: CaseNode, when: WhenNode): CaseNode;
     cloneWithThen(caseNode: CaseNode, then: OperationNode): CaseNode;
-    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): CaseNode;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, "else" | "isStatement">>): CaseNode;
 }>;

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

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

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

@@ -1,7 +1,7 @@
 import { OperationNode } from './operation-node.js';
-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"];
+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", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
 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 ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
 export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isColumnDataType = exports.DataTypeNode = void 0;
+exports.DataTypeNode = void 0;
+exports.isColumnDataType = isColumnDataType;
 const object_utils_js_1 = require("../util/object-utils.js");
 const SIMPLE_COLUMN_DATA_TYPES = [
     'varchar',
@@ -33,6 +34,19 @@ const SIMPLE_COLUMN_DATA_TYPES = [
     'json',
     'jsonb',
     'blob',
+    'varbinary',
+    'int4range',
+    'int4multirange',
+    'int8range',
+    'int8multirange',
+    'numrange',
+    'nummultirange',
+    'tsrange',
+    'tsmultirange',
+    'tstzrange',
+    'tstzmultirange',
+    'daterange',
+    'datemultirange',
 ];
 const COLUMN_DATA_TYPE_REGEX = [
     /^varchar\(\d+\)$/,
@@ -42,9 +56,10 @@ const COLUMN_DATA_TYPE_REGEX = [
     /^binary\(\d+\)$/,
     /^datetime\(\d+\)$/,
     /^time\(\d+\)$/,
-    /^timez\(\d+\)$/,
+    /^timetz\(\d+\)$/,
     /^timestamp\(\d+\)$/,
     /^timestamptz\(\d+\)$/,
+    /^varbinary\(\d+\)$/,
 ];
 /**
  * @internal
@@ -69,4 +84,3 @@ function isColumnDataType(dataType) {
     }
     return false;
 }
-exports.isColumnDataType = isColumnDataType;

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

@@ -10,6 +10,7 @@ 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;
@@ -21,7 +22,9 @@ export interface DeleteQueryNode extends OperationNode {
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
     readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal

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

@@ -3,6 +3,7 @@ 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';
@@ -21,7 +22,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal

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

@@ -1,6 +1,7 @@
 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';
@@ -12,6 +13,8 @@ export interface MergeQueryNode extends OperationNode {
     readonly whens?: ReadonlyArray<WhenNode>;
     readonly with?: WithNode;
     readonly top?: TopNode;
+    readonly output?: OutputNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal

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

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOperationNodeSource = void 0;
+exports.isOperationNodeSource = isOperationNodeSource;
 const object_utils_js_1 = require("../util/object-utils.js");
 function isOperationNodeSource(obj) {
     return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.toOperationNode);
 }
-exports.isOperationNodeSource = isOperationNodeSource;

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

@@ -91,6 +91,7 @@ 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.
  *
@@ -105,9 +106,12 @@ import { TopNode } from './top-node.js';
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -117,7 +121,10 @@ import { TopNode } from './top-node.js';
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 export declare class OperationNodeTransformer {
@@ -211,6 +218,7 @@ export declare class OperationNodeTransformer {
     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/cjs/operation-node/operation-node-transformer.js

@@ -17,9 +17,12 @@ const require_all_props_js_1 = require("../util/require-all-props.js");
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -29,7 +32,10 @@ const require_all_props_js_1 = require("../util/require-all-props.js");
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 class OperationNodeTransformer {
@@ -127,6 +133,7 @@ class OperationNodeTransformer {
         CastNode: this.transformCast.bind(this),
         FetchNode: this.transformFetch.bind(this),
         TopNode: this.transformTop.bind(this),
+        OutputNode: this.transformOutput.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -262,12 +269,14 @@ class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             ignore: node.ignore,
             replace: node.replace,
             explain: this.transformNode(node.explain),
             defaultValues: node.defaultValues,
             top: this.transformNode(node.top),
+            output: this.transformNode(node.output),
         });
     }
     transformValues(node) {
@@ -284,11 +293,13 @@ class OperationNodeTransformer {
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             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) {
@@ -329,6 +340,7 @@ class OperationNodeTransformer {
             endModifiers: this.transformNodeList(node.endModifiers),
             nullsNotDistinct: node.nullsNotDistinct,
             identity: node.identity,
+            ifNotExists: node.ifNotExists,
         });
     }
     transformAddColumn(node) {
@@ -379,10 +391,12 @@ class OperationNodeTransformer {
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             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) {
@@ -684,6 +698,7 @@ class OperationNodeTransformer {
             kind: 'AggregateFunctionNode',
             aggregated: this.transformNodeList(node.aggregated),
             distinct: node.distinct,
+            orderBy: this.transformNode(node.orderBy),
             filter: this.transformNode(node.filter),
             func: node.func,
             over: this.transformNode(node.over),
@@ -794,6 +809,8 @@ class OperationNodeTransformer {
             whens: this.transformNodeList(node.whens),
             with: this.transformNode(node.with),
             top: this.transformNode(node.top),
+            endModifiers: this.transformNodeList(node.endModifiers),
+            output: this.transformNode(node.output),
         });
     }
     transformMatched(node) {
@@ -834,6 +851,12 @@ class OperationNodeTransformer {
             modifiers: node.modifiers,
         });
     }
+    transformOutput(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'OutputNode',
+            selections: this.transformNodeList(node.selections),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -91,6 +91,7 @@ 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[];
@@ -188,4 +189,5 @@ export declare abstract class OperationNodeVisitor {
     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/cjs/operation-node/operation-node-visitor.js

@@ -100,6 +100,7 @@ class OperationNodeVisitor {
         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/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' | 'MergeQueryNode' | 'MatchedNode' | 'AddIndexNode' | 'CastNode' | 'FetchNode' | 'TopNode';
+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/cjs/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/cjs/operation-node/operator-node.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJSONOperator = exports.isArithmeticOperator = exports.isComparisonOperator = exports.isBinaryOperator = exports.isOperator = exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.JSON_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+exports.OperatorNode = exports.OPERATORS = exports.UNARY_OPERATORS = exports.UNARY_FILTER_OPERATORS = exports.BINARY_OPERATORS = exports.JSON_OPERATORS = exports.ARITHMETIC_OPERATORS = exports.COMPARISON_OPERATORS = void 0;
+exports.isOperator = isOperator;
+exports.isBinaryOperator = isBinaryOperator;
+exports.isComparisonOperator = isComparisonOperator;
+exports.isArithmeticOperator = isArithmeticOperator;
+exports.isJSONOperator = isJSONOperator;
 const object_utils_js_1 = require("../util/object-utils.js");
 exports.COMPARISON_OPERATORS = [
     '=',
@@ -22,9 +27,11 @@ exports.COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '^@',
     '&&',
     '?',
     '?&',
+    '?|',
     '!<',
     '!>',
     '<=>',
@@ -86,20 +93,15 @@ exports.OperatorNode = (0, object_utils_js_1.freeze)({
 function isOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.OPERATORS.includes(op);
 }
-exports.isOperator = isOperator;
 function isBinaryOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.BINARY_OPERATORS.includes(op);
 }
-exports.isBinaryOperator = isBinaryOperator;
 function isComparisonOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.COMPARISON_OPERATORS.includes(op);
 }
-exports.isComparisonOperator = isComparisonOperator;
 function isArithmeticOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.ARITHMETIC_OPERATORS.includes(op);
 }
-exports.isArithmeticOperator = isArithmeticOperator;
 function isJSONOperator(op) {
     return (0, object_utils_js_1.isString)(op) && exports.JSON_OPERATORS.includes(op);
 }
-exports.isJSONOperator = isJSONOperator;