kysely 0.9.7 → 0.10.1

package/README.md

@@ -67,7 +67,9 @@ import { Kysely, PostgresDialect } from 'kysely'
 interface Person {
   id: number
   first_name: string
-  last_name: string
+  // If the column is nullable in the db, make its type nullable.
+  // Don't use optional properties.
+  last_name: string | null
   gender: 'male' | 'female' | 'other'
 }
 
@@ -172,9 +174,9 @@ export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('person')
     .addColumn('id', 'serial', (col) => col.primaryKey())
-    .addColumn('first_name', 'varchar')
+    .addColumn('first_name', 'varchar', (col) => col.notNull())
     .addColumn('last_name', 'varchar')
-    .addColumn('gender', 'varchar(50)')
+    .addColumn('gender', 'varchar(50)', (col) => col.notNull())
     .execute()
 
   await db.schema
@@ -182,9 +184,9 @@ export async function up(db: Kysely<any>): Promise<void> {
     .addColumn('id', 'serial', (col) => col.primaryKey())
     .addColumn('name', 'varchar', (col) => col.notNull().unique())
     .addColumn('owner_id', 'integer', (col) =>
-      col.references('person.id').onDelete('cascade')
+      col.references('person.id').onDelete('cascade').notNull()
     )
-    .addColumn('species', 'varchar')
+    .addColumn('species', 'varchar', (col) => col.notNull())
     .execute()
 
   await db.schema
@@ -208,18 +210,18 @@ import { Kysely } from 'kysely'
 export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('person')
-    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
-    .addColumn('first_name', 'varchar')
-    .addColumn('last_name', 'varchar')
-    .addColumn('gender', 'varchar(50)')
+    .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+    .addColumn('first_name', 'varchar(255)', (col) => col.notNull())
+    .addColumn('last_name', 'varchar(255)')
+    .addColumn('gender', 'varchar(50)', (col) => col.notNull())
     .execute()
 
   await db.schema
     .createTable('pet')
-    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
-    .addColumn('name', 'varchar', (col) => col.notNull().unique())
-    .addColumn('owner_id', 'integer')
-    .addColumn('species', 'varchar')
+    .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+    .addColumn('name', 'varchar(255)', (col) => col.notNull().unique())
+    .addColumn('owner_id', 'integer', (col) => col.notNull())
+    .addColumn('species', 'varchar(255)', (col) => col.notNull())
     .addForeignKeyConstraint(
       'pet_owner_id_fk', ['owner_id'], 'person', ['id'],
       (cb) => cb.onDelete('cascade')

package/dist/cjs/driver/runtime-driver.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeDriver = void 0;
+const performance_now_js_1 = require("../util/performance-now.js");
 /**
  * A small wrapper around {@link Driver} that makes sure the driver is
  * initialized before it is used, only initialized and destroyed
@@ -75,7 +76,7 @@ class RuntimeConnection {
         this.#log = log;
     }
     async executeQuery(compiledQuery) {
-        const startTime = process.hrtime.bigint();
+        const startTime = (0, performance_now_js_1.performanceNow)();
         try {
             return await this.#connection.executeQuery(compiledQuery);
         }
@@ -101,8 +102,6 @@ class RuntimeConnection {
         }));
     }
     #calculateDurationMillis(startTime) {
-        const endTime = process.hrtime.bigint();
-        const durationNanos = Number(endTime - startTime);
-        return durationNanos / 1_000_000;
+        return (0, performance_now_js_1.performanceNow)() - startTime;
     }
 }

package/dist/cjs/index.d.ts

@@ -19,6 +19,8 @@ export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
 export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
+export * from './schema/create-view-builder.js';
+export * from './schema/drop-view-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';
 export * from './driver/database-connection.js';

package/dist/cjs/index.js

@@ -31,6 +31,8 @@ __exportStar(require("./schema/drop-schema-builder.js"), exports);
 __exportStar(require("./schema/column-definition-builder.js"), exports);
 __exportStar(require("./schema/foreign-key-constraint-builder.js"), exports);
 __exportStar(require("./schema/alter-table-builder.js"), exports);
+__exportStar(require("./schema/create-view-builder.js"), exports);
+__exportStar(require("./schema/drop-view-builder.js"), exports);
 __exportStar(require("./dynamic/dynamic.js"), exports);
 __exportStar(require("./driver/driver.js"), exports);
 __exportStar(require("./driver/database-connection.js"), exports);

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

@@ -15,10 +15,10 @@ exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
             kind: 'ColumnDefinitionNode',
             column: column_node_js_1.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/cjs/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/cjs/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/cjs/operation-node/create-table-node.js

@@ -22,10 +22,10 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
             columns: (0, object_utils_js_1.freeze)([...createTable.columns, column]),
         });
     },
-    cloneWithModifier(createTable, modifier) {
+    cloneWithIfNotExists(createTable, ifNotExists) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,
-            modifier,
+            ifNotExists,
         });
     },
     cloneWithConstraint(createTable, constraint) {

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

@@ -0,0 +1,22 @@
+import { ColumnNode } from './column-node.js';
+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 CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
+export interface CreateViewNode extends OperationNode {
+    readonly kind: 'CreateViewNode';
+    readonly name: IdentifierNode;
+    readonly materialized?: boolean;
+    readonly orReplace?: boolean;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly as?: SelectQueryNode | RawNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateViewNode: Readonly<{
+    is(node: OperationNode): node is CreateViewNode;
+    create(name: string): CreateViewNode;
+    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): CreateViewNode;
+}>;

package/dist/cjs/operation-node/create-view-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateViewNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.CreateViewNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CreateViewNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CreateViewNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(createView, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...createView,
+            ...params,
+        });
+    },
+});

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

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

package/dist/cjs/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/cjs/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(createSchema: DropSchemaNode, modifier: DropSchemaNodeModifier): DropSchemaNode;
+    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): DropSchemaNode;
 }>;

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

@@ -17,10 +17,10 @@ exports.DropSchemaNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWithModifier(createSchema, modifier) {
+    cloneWith(dropSchema, params) {
         return (0, object_utils_js_1.freeze)({
-            ...createSchema,
-            modifier,
+            ...dropSchema,
+            ...params,
         });
     },
 });

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

@@ -16,10 +16,10 @@ exports.DropTableNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWithModifier(dropIndex, modifier) {
+    cloneWith(dropIndex, params) {
         return (0, object_utils_js_1.freeze)({
             ...dropIndex,
-            modifier,
+            ...params,
         });
     },
 });

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropViewNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.DropViewNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropViewNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropViewNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropView, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropView,
+            ...params,
+        });
+    },
+});

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedAlwaysAsNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const raw_node_js_1 = require("./raw-node.js");
+/**
+ * @internal
+ */
+exports.GeneratedAlwaysAsNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'GeneratedAlwaysAsNode';
+    },
+    create(expression) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GeneratedAlwaysAsNode',
+            expression: raw_node_js_1.RawNode.createWithSql(expression),
+        });
+    },
+    cloneWith(node, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...params,
+        });
+    },
+});

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

@@ -58,6 +58,10 @@ import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
+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';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -145,6 +149,10 @@ export declare class OperationNodeTransformer {
     protected transformModifyColumn(node: ModifyColumnNode): ModifyColumnNode;
     protected transformAddConstraint(node: AddConstraintNode): AddConstraintNode;
     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 transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -33,7 +33,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
  */
 class OperationNodeTransformer {
     nodeStack = [];
-    #transformers = {
+    #transformers = (0, object_utils_js_1.freeze)({
         AliasNode: this.transformAlias.bind(this),
         ColumnNode: this.transformColumn.bind(this),
         IdentifierNode: this.transformIdentifier.bind(this),
@@ -93,7 +93,11 @@ class OperationNodeTransformer {
         DropConstraintNode: this.transformDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
         UnionNode: this.transformUnion.bind(this),
-    };
+        CreateViewNode: this.transformCreateView.bind(this),
+        DropViewNode: this.transformDropView.bind(this),
+        GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.transformDefaultValue.bind(this),
+    });
     transformNode = (node) => {
         if (!node) {
             return undefined;
@@ -115,7 +119,7 @@ class OperationNodeTransformer {
             from: this.transformNode(node.from),
             selections: this.transformNodeList(node.selections),
             distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
-            isDistinct: node.isDistinct,
+            distinct: node.distinct,
             joins: this.transformNodeList(node.joins),
             groupBy: this.transformNode(node.groupBy),
             orderBy: this.transformNode(node.orderBy),
@@ -257,7 +261,7 @@ class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             constraints: this.transformNodeList(node.constraints),
-            modifier: node.modifier,
+            ifNotExists: node.ifNotExists,
         };
     }
     transformColumnDefinition(node) {
@@ -266,12 +270,13 @@ class OperationNodeTransformer {
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
             references: this.transformNode(node.references),
-            isPrimaryKey: node.isPrimaryKey,
-            isAutoIncrementing: node.isAutoIncrementing,
-            isUnique: node.isUnique,
-            isNullable: node.isNullable,
+            primaryKey: node.primaryKey,
+            autoIncrement: node.autoIncrement,
+            unique: node.unique,
+            nullable: node.nullable,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
+            generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
         };
     }
     transformAddColumn(node) {
@@ -284,7 +289,7 @@ class OperationNodeTransformer {
         return {
             kind: 'DropTableNode',
             table: this.transformNode(node.table),
-            modifier: node.modifier,
+            ifExists: node.ifExists,
         };
     }
     transformOrderBy(node) {
@@ -378,7 +383,7 @@ class OperationNodeTransformer {
             kind: 'DropIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
-            modifier: node.modifier,
+            ifExists: node.ifExists,
         };
     }
     transformPrimaryKeyConstraint(node) {
@@ -457,7 +462,7 @@ class OperationNodeTransformer {
         return {
             kind: 'DropSchemaNode',
             schema: this.transformNode(node.schema),
-            modifier: node.modifier,
+            ifExists: node.ifExists,
         };
     }
     transformAlterTable(node) {
@@ -518,6 +523,37 @@ class OperationNodeTransformer {
             constraintName: this.transformNode(node.constraintName),
         };
     }
+    transformCreateView(node) {
+        return {
+            kind: 'CreateViewNode',
+            name: this.transformNode(node.name),
+            orReplace: node.orReplace,
+            materialized: node.materialized,
+            columns: this.transformNodeList(node.columns),
+            as: this.transformNode(node.as),
+        };
+    }
+    transformDropView(node) {
+        return {
+            kind: 'DropViewNode',
+            name: this.transformNode(node.name),
+            ifExists: node.ifExists,
+            materialized: node.materialized,
+        };
+    }
+    transformGeneratedAlwaysAs(node) {
+        return {
+            kind: 'GeneratedAlwaysAsNode',
+            expression: this.transformNode(node.expression),
+            stored: node.stored,
+        };
+    }
+    transformDefaultValue(node) {
+        return {
+            kind: 'DefaultValueNode',
+            defaultValue: this.transformNode(node.defaultValue),
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -58,6 +58,10 @@ import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
+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';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -121,4 +125,8 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitValue(_: ValueNode): void;
     protected abstract visitPrimitiveValueList(_: PrimitiveValueListNode): void;
     protected abstract visitOperator(node: OperatorNode): void;
+    protected abstract visitCreateView(node: CreateViewNode): void;
+    protected abstract visitDropView(node: DropViewNode): void;
+    protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected abstract visitDefaultValue(node: DefaultValueNode): void;
 }