kysely 0.9.9 → 0.11.1

package/dist/esm/index.d.ts

@@ -3,6 +3,9 @@ export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
 export * from './query-builder/expression-builder.js';
+export * from './query-builder/insert-result.js';
+export * from './query-builder/delete-result.js';
+export * from './query-builder/update-result.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -37,6 +40,11 @@ export * from './dialect/mysql/mysql-query-compiler.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/mysql/mysql-introspector.js';
 export * from './dialect/mysql/mysql-adapter.js';
+export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-query-compiler.js';
+export * from './dialect/sqlite/sqlite-driver.js';
+export * from './dialect/sqlite/sqlite-introspector.js';
+export * from './dialect/sqlite/sqlite-adapter.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migration.js';

package/dist/esm/index.js

@@ -3,6 +3,9 @@ export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
 export * from './query-builder/expression-builder.js';
+export * from './query-builder/insert-result.js';
+export * from './query-builder/delete-result.js';
+export * from './query-builder/update-result.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -37,6 +40,11 @@ export * from './dialect/mysql/mysql-query-compiler.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/mysql/mysql-introspector.js';
 export * from './dialect/mysql/mysql-adapter.js';
+export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-query-compiler.js';
+export * from './dialect/sqlite/sqlite-driver.js';
+export * from './dialect/sqlite/sqlite-introspector.js';
+export * from './dialect/sqlite/sqlite-adapter.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migration.js';

package/dist/esm/kysely.d.ts

@@ -116,7 +116,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -146,17 +146,19 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
+     *       id: db.generated,
      *       first_name: 'Jennifer',
-     *      last_name: 'Aniston',
+     *       last_name: 'Aniston',
      *     })
      *     .returning('id')
-     *     .executeTakeFirst()
+     *     .executeTakeFirstOrThrow()
      *
      *   await someFunction(trx, jennifer)
      *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer!.id,
+     *       id: db.generated,
+     *       user_id: jennifer.id,
      *       name: 'Catto',
      *       species: 'cat'
      *     })

package/dist/esm/kysely.js

@@ -151,7 +151,7 @@ export class Kysely extends QueryCreator {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -183,17 +183,19 @@ export class Kysely extends QueryCreator {
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
+     *       id: db.generated,
      *       first_name: 'Jennifer',
-     *      last_name: 'Aniston',
+     *       last_name: 'Aniston',
      *     })
      *     .returning('id')
-     *     .executeTakeFirst()
+     *     .executeTakeFirstOrThrow()
      *
      *   await someFunction(trx, jennifer)
      *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer!.id,
+     *       id: db.generated,
+     *       user_id: jennifer.id,
      *       name: 'Catto',
      *       species: 'cat'
      *     })

package/dist/esm/migration/migration.d.ts

@@ -62,5 +62,5 @@ export declare class MigrationModule {
 }
 export interface Migration {
     up(db: Kysely<any>): Promise<void>;
-    down(db: Kysely<any>): Promise<void>;
+    down?(db: Kysely<any>): Promise<void>;
 }

package/dist/esm/migration/migration.js

@@ -57,7 +57,7 @@ async function ensureMigrationTableExists(db) {
                 .execute();
         }
         catch (error) {
-            // At least on postgres, `if not exists` doesn't guarantee the `create table`
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
             if (!(await doesTableExists(db, MIGRATION_TABLE))) {
@@ -77,7 +77,7 @@ async function ensureMigrationLockTableExists(db) {
                 .execute();
         }
         catch (error) {
-            // At least on postgres, `if not exists` doesn't guarantee the `create table`
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
             if (!(await doesTableExists(db, MIGRATION_LOCK_TABLE))) {
@@ -179,5 +179,5 @@ function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNam
     }
 }
 function isMigration(obj) {
-    return isObject(obj) && isFunction(obj.up) && isFunction(obj.down);
+    return isObject(obj) && isFunction(obj.up);
 }

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

@@ -1,10 +1,11 @@
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-import { ValueNode } from './value-node.js';
 export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
@@ -12,12 +13,13 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly column: ColumnNode;
     readonly dataType: ColumnDataTypeNode;
     readonly references?: ReferencesNode;
-    readonly isPrimaryKey: boolean;
-    readonly isAutoIncrementing: boolean;
-    readonly isUnique: boolean;
-    readonly isNullable: boolean;
-    readonly defaultTo?: ValueNode | RawNode;
+    readonly primaryKey: boolean;
+    readonly autoIncrement: boolean;
+    readonly unique: boolean;
+    readonly nullable: boolean;
+    readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
+    readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
 }
 /**
  * @internal

package/dist/esm/operation-node/column-definition-node.js

@@ -12,10 +12,10 @@ export const ColumnDefinitionNode = freeze({
             kind: 'ColumnDefinitionNode',
             column: ColumnNode.create(column),
             dataType,
-            isPrimaryKey: false,
-            isAutoIncrementing: false,
-            isUnique: false,
-            isNullable: true,
+            primaryKey: false,
+            autoIncrement: false,
+            unique: false,
+            nullable: true,
         });
     },
     cloneWith(node, props) {

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

@@ -1,11 +1,10 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type CreateSchemaNodeModifier = 'IfNotExists';
 export declare type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
 export interface CreateSchemaNode extends OperationNode {
     readonly kind: 'CreateSchemaNode';
     readonly schema: IdentifierNode;
-    readonly modifier?: CreateSchemaNodeModifier;
+    readonly ifNotExists?: boolean;
 }
 /**
  * @internal

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

@@ -2,12 +2,11 @@ import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
-export declare type CreateTableNodeModifier = 'IfNotExists';
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnDefinitionNode>;
-    readonly modifier?: CreateTableNodeModifier;
+    readonly ifNotExists?: boolean;
     readonly constraints?: ReadonlyArray<ConstraintNode>;
 }
 /**
@@ -17,6 +16,6 @@ export declare const CreateTableNode: Readonly<{
     is(node: OperationNode): node is CreateTableNode;
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
-    cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): CreateTableNode;
+    cloneWithIfNotExists(createTable: CreateTableNode, ifNotExists: boolean): CreateTableNode;
     cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
 }>;

package/dist/esm/operation-node/create-table-node.js

@@ -19,10 +19,10 @@ export const CreateTableNode = freeze({
             columns: freeze([...createTable.columns, column]),
         });
     },
-    cloneWithModifier(createTable, modifier) {
+    cloneWithIfNotExists(createTable, ifNotExists) {
         return freeze({
             ...createTable,
-            modifier,
+            ifNotExists,
         });
     },
     cloneWithConstraint(createTable, constraint) {

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

@@ -3,12 +3,13 @@ import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { SelectQueryNode } from './select-query-node.js';
-export declare type CreateViewNodeModifier = 'OrReplace';
 export declare type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
     readonly name: IdentifierNode;
-    readonly modifier?: CreateViewNodeModifier;
+    readonly materialized?: boolean;
+    readonly orReplace?: boolean;
+    readonly ifNotExists?: boolean;
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly as?: SelectQueryNode | RawNode;
 }

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+import { ValueNode } from './value-node.js';
+export interface DefaultValueNode extends OperationNode {
+    readonly kind: 'DefaultValueNode';
+    readonly defaultValue: ValueNode | RawNode;
+}
+/**
+ * @internal
+ */
+export declare const DefaultValueNode: Readonly<{
+    is(node: OperationNode): node is DefaultValueNode;
+    create(defaultValue: ValueNode | RawNode): DefaultValueNode;
+}>;

package/dist/esm/operation-node/default-value-node.js

@@ -0,0 +1,15 @@
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DefaultValueNode = freeze({
+    is(node) {
+        return node.kind === 'DefaultValueNode';
+    },
+    create(defaultValue) {
+        return freeze({
+            kind: 'DefaultValueNode',
+            defaultValue,
+        });
+    },
+});

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

@@ -2,12 +2,11 @@ import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
-export declare type DropIndexNodeModifier = 'IfExists';
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
     readonly name: IdentifierNode;
     readonly table?: TableNode;
-    readonly modifier?: DropIndexNodeModifier;
+    readonly ifExists?: boolean;
 }
 /**
  * @internal

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

@@ -1,11 +1,10 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type DropSchemaNodeModifier = 'IfExists';
 export declare type DropSchemaNodeParams = Omit<Partial<DropSchemaNode>, 'kind' | 'schema'>;
 export interface DropSchemaNode extends OperationNode {
     readonly kind: 'DropSchemaNode';
     readonly schema: IdentifierNode;
-    readonly modifier?: DropSchemaNodeModifier;
+    readonly ifExists?: boolean;
 }
 /**
  * @internal
@@ -13,5 +12,5 @@ export interface DropSchemaNode extends OperationNode {
 export declare const DropSchemaNode: Readonly<{
     is(node: OperationNode): node is DropSchemaNode;
     create(schema: string, params?: DropSchemaNodeParams | undefined): DropSchemaNode;
-    cloneWithModifier(dropSchema: DropSchemaNode, modifier: DropSchemaNodeModifier): DropSchemaNode;
+    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): DropSchemaNode;
 }>;

package/dist/esm/operation-node/drop-schema-node.js

@@ -14,10 +14,10 @@ export const DropSchemaNode = freeze({
             ...params,
         });
     },
-    cloneWithModifier(dropSchema, modifier) {
+    cloneWith(dropSchema, params) {
         return freeze({
             ...dropSchema,
-            modifier,
+            ...params,
         });
     },
 });

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

@@ -1,11 +1,10 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
-export declare type DropTableNodeModifier = 'IfExists';
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
     readonly table: TableNode;
-    readonly modifier?: DropTableNodeModifier;
+    readonly ifExists?: boolean;
 }
 /**
  * @internal
@@ -13,5 +12,5 @@ export interface DropTableNode extends OperationNode {
 export declare const DropTableNode: Readonly<{
     is(node: OperationNode): node is DropTableNode;
     create(table: TableNode, params?: DropTablexNodeParams | undefined): DropTableNode;
-    cloneWithModifier(dropIndex: DropTableNode, modifier: DropTableNodeModifier): DropTableNode;
+    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): DropTableNode;
 }>;

package/dist/esm/operation-node/drop-table-node.js

@@ -13,10 +13,10 @@ export const DropTableNode = freeze({
             ...params,
         });
     },
-    cloneWithModifier(dropIndex, modifier) {
+    cloneWith(dropIndex, params) {
         return freeze({
             ...dropIndex,
-            modifier,
+            ...params,
         });
     },
 });

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

@@ -1,11 +1,11 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type DropViewNodeModifier = 'IfExists';
 export declare type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
 export interface DropViewNode extends OperationNode {
     readonly kind: 'DropViewNode';
     readonly name: IdentifierNode;
-    readonly modifier?: DropViewNodeModifier;
+    readonly ifExists?: boolean;
+    readonly materialized?: boolean;
 }
 /**
  * @internal
@@ -13,5 +13,5 @@ export interface DropViewNode extends OperationNode {
 export declare const DropViewNode: Readonly<{
     is(node: OperationNode): node is DropViewNode;
     create(name: string): DropViewNode;
-    cloneWithModifier(dropView: DropViewNode, modifier: DropViewNodeModifier): DropViewNode;
+    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): DropViewNode;
 }>;

package/dist/esm/operation-node/drop-view-node.js

@@ -13,10 +13,10 @@ export const DropViewNode = freeze({
             name: IdentifierNode.create(name),
         });
     },
-    cloneWithModifier(dropView, modifier) {
+    cloneWith(dropView, params) {
         return freeze({
             ...dropView,
-            modifier,
+            ...params,
         });
     },
 });

package/dist/esm/operation-node/generated-always-as-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
+export interface GeneratedAlwaysAsNode extends OperationNode {
+    readonly kind: 'GeneratedAlwaysAsNode';
+    readonly expression: RawNode;
+    readonly stored?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const GeneratedAlwaysAsNode: Readonly<{
+    is(node: OperationNode): node is GeneratedAlwaysAsNode;
+    create(expression: string): GeneratedAlwaysAsNode;
+    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
+}>;

package/dist/esm/operation-node/generated-always-as-node.js

@@ -0,0 +1,22 @@
+import { freeze } from '../util/object-utils.js';
+import { RawNode } from './raw-node.js';
+/**
+ * @internal
+ */
+export const GeneratedAlwaysAsNode = freeze({
+    is(node) {
+        return node.kind === 'GeneratedAlwaysAsNode';
+    },
+    create(expression) {
+        return freeze({
+            kind: 'GeneratedAlwaysAsNode',
+            expression: RawNode.createWithSql(expression),
+        });
+    },
+    cloneWith(node, params) {
+        return freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

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

@@ -1,18 +1,14 @@
-import { AndNode } from './and-node.js';
-import { FilterNode } from './filter-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
-export declare type HavingNodeChild = FilterNode | AndNode | OrNode | ParensNode;
 export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
-    readonly having: HavingNodeChild;
+    readonly having: FilterExpressionNode;
 }
 /**
  * @internal
  */
 export declare const HavingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
-    create(filter: HavingNodeChild): HavingNode;
-    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', having: HavingNodeChild): HavingNode;
+    create(filter: FilterExpressionNode): HavingNode;
+    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', filter: FilterExpressionNode): HavingNode;
 }>;

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

@@ -14,12 +14,12 @@ export const HavingNode = freeze({
             having: filter,
         });
     },
-    cloneWithFilter(havingNode, op, having) {
+    cloneWithFilter(havingNode, op, filter) {
         return freeze({
             ...havingNode,
             having: op === 'And'
-                ? AndNode.create(havingNode.having, having)
-                : OrNode.create(havingNode.having, having),
+                ? AndNode.create(havingNode.having, filter)
+                : OrNode.create(havingNode.having, filter),
         });
     },
 });

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

@@ -1,18 +1,15 @@
 import { AliasNode } from './alias-node.js';
-import { AndNode } from './and-node.js';
-import { FilterNode } from './filter-node.js';
+import { OnNode } from './on-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
 import { TableNode } from './table-node.js';
 export declare type JoinTableNode = TableNode | AliasNode;
 export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin';
-export declare type JoinNodeOnNode = FilterNode | AndNode | OrNode | ParensNode;
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;
     readonly table: JoinTableNode;
-    readonly on?: JoinNodeOnNode;
+    readonly on?: OnNode;
 }
 /**
  * @internal
@@ -20,7 +17,7 @@ export interface JoinNode extends OperationNode {
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
-    createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    createWithOn(joinType: JoinType, table: JoinTableNode, on: FilterExpressionNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
 }>;

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

@@ -1,6 +1,5 @@
 import { freeze } from '../util/object-utils.js';
-import { AndNode } from './and-node.js';
-import { OrNode } from './or-node.js';
+import { OnNode } from './on-node.js';
 /**
  * @internal
  */
@@ -21,19 +20,23 @@ export const JoinNode = freeze({
             kind: 'JoinNode',
             joinType,
             table,
-            on,
+            on: OnNode.create(on),
         });
     },
-    cloneWithOn(joinNode, on) {
+    cloneWithOn(joinNode, filter) {
         return freeze({
             ...joinNode,
-            on: joinNode.on ? AndNode.create(joinNode.on, on) : on,
+            on: joinNode.on
+                ? OnNode.cloneWithFilter(joinNode.on, 'And', filter)
+                : OnNode.create(filter),
         });
     },
-    cloneWithOrOn(joinNode, on) {
+    cloneWithOrOn(joinNode, filter) {
         return freeze({
             ...joinNode,
-            on: joinNode.on ? OrNode.create(joinNode.on, on) : on,
+            on: joinNode.on
+                ? OnNode.cloneWithFilter(joinNode.on, 'Or', filter)
+                : OnNode.create(filter),
         });
     },
 });

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

@@ -0,0 +1,14 @@
+import { FilterExpressionNode } from './operation-node-utils.js';
+import { OperationNode } from './operation-node.js';
+export interface OnNode extends OperationNode {
+    readonly kind: 'OnNode';
+    readonly on: FilterExpressionNode;
+}
+/**
+ * @internal
+ */
+export declare const OnNode: Readonly<{
+    is(node: OperationNode): node is OnNode;
+    create(filter: FilterExpressionNode): OnNode;
+    cloneWithFilter(onNode: OnNode, op: 'And' | 'Or', filter: FilterExpressionNode): OnNode;
+}>;

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

@@ -0,0 +1,25 @@
+import { freeze } from '../util/object-utils.js';
+import { AndNode } from './and-node.js';
+import { OrNode } from './or-node.js';
+/**
+ * @internal
+ */
+export const OnNode = freeze({
+    is(node) {
+        return node.kind === 'OnNode';
+    },
+    create(filter) {
+        return freeze({
+            kind: 'OnNode',
+            on: filter,
+        });
+    },
+    cloneWithFilter(onNode, op, filter) {
+        return freeze({
+            ...onNode,
+            on: op === 'And'
+                ? AndNode.create(onNode.on, filter)
+                : OrNode.create(onNode.on, filter),
+        });
+    },
+});

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

@@ -60,6 +60,9 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { OnNode } from './on-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -149,6 +152,9 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
+    protected transformOn(node: OnNode): OnNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;