kysely 0.9.7 → 0.10.1

package/dist/esm/query-compiler/default-query-compiler.js

@@ -35,7 +35,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileDistinctOn(node.distinctOnSelections);
             this.append(' ');
         }
-        if (node.isDistinct) {
+        if (node.distinct) {
             this.append('distinct');
             this.append(' ');
         }
@@ -287,7 +287,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitCreateTable(node) {
         this.append('create table ');
-        if (node.modifier === 'IfNotExists') {
+        if (node.ifNotExists) {
             this.append('if not exists ');
         }
         this.visitNode(node.table);
@@ -299,21 +299,25 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.column);
         this.append(' ');
         this.visitNode(node.dataType);
+        if (node.generatedAlwaysAs) {
+            this.append(' ');
+            this.visitNode(node.generatedAlwaysAs);
+        }
         if (node.defaultTo) {
-            this.append(' default ');
+            this.append(' ');
             this.visitNode(node.defaultTo);
         }
-        if (!node.isNullable) {
+        if (!node.nullable) {
             this.append(' not null');
         }
-        if (node.isAutoIncrementing) {
+        if (node.autoIncrement) {
             this.append(' ');
             this.append(this.getAutoIncrement());
         }
-        if (node.isUnique) {
+        if (node.unique) {
             this.append(' unique');
         }
-        if (node.isPrimaryKey) {
+        if (node.primaryKey) {
             this.append(' primary key');
         }
         if (node.references) {
@@ -345,7 +349,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitDropTable(node) {
         this.append('drop table ');
-        if (node.modifier === 'IfExists') {
+        if (node.ifExists) {
             this.append('if exists ');
         }
         this.visitNode(node.table);
@@ -467,7 +471,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitDropIndex(node) {
         this.append('drop index ');
-        if (node.modifier === 'IfExists') {
+        if (node.ifExists) {
             this.append('if exists ');
         }
         this.visitNode(node.name);
@@ -478,14 +482,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitCreateSchema(node) {
         this.append('create schema ');
-        if (node.modifier === 'IfNotExists') {
+        if (node.ifNotExists) {
             this.append('if not exists ');
         }
         this.visitNode(node.schema);
     }
     visitDropSchema(node) {
         this.append('drop schema ');
-        if (node.modifier === 'IfExists') {
+        if (node.ifExists) {
             this.append('if exists ');
         }
         this.visitNode(node.schema);
@@ -644,6 +648,50 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.visitNode(node.union);
     }
+    visitCreateView(node) {
+        this.append('create ');
+        if (node.orReplace) {
+            this.append('or replace ');
+        }
+        if (node.materialized) {
+            this.append('materialized ');
+        }
+        this.append('view ');
+        this.visitNode(node.name);
+        this.append(' ');
+        if (node.columns) {
+            this.append('(');
+            this.compileList(node.columns);
+            this.append(') ');
+        }
+        if (node.as) {
+            this.append('as ');
+            this.visitNode(node.as);
+        }
+    }
+    visitDropView(node) {
+        this.append('drop ');
+        if (node.materialized) {
+            this.append('materialized ');
+        }
+        this.append('view ');
+        if (node.ifExists) {
+            this.append('if exists ');
+        }
+        this.visitNode(node.name);
+    }
+    visitGeneratedAlwaysAs(node) {
+        this.append('generated always as (');
+        this.visitNode(node.expression);
+        this.append(')');
+        if (node.stored) {
+            this.append(' stored');
+        }
+    }
+    visitDefaultValue(node) {
+        this.append('default ');
+        this.visitNode(node.defaultValue);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/esm/query-compiler/query-compiler.d.ts

@@ -2,13 +2,15 @@ import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../operation-node/create-index-node.js';
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { CreateTableNode } from '../operation-node/create-table-node.js';
+import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
+import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
-export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | AlterTableNode | DropTableNode | DropIndexNode | CreateSchemaNode | DropSchemaNode | RawNode;
+export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -41,5 +41,5 @@ export interface RawBuilderProps {
     readonly queryId: QueryId;
     readonly executor: QueryExecutor;
     readonly sql: string;
-    readonly parameters?: any;
+    readonly parameters?: ReadonlyArray<unknown>;
 }

package/dist/esm/schema/alter-table-builder.d.ts

@@ -63,7 +63,7 @@ export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
-    increments(): AlterTableAddColumnBuilder;
+    autoIncrement(): AlterTableAddColumnBuilder;
     primaryKey(): AlterTableAddColumnBuilder;
     references(ref: string): AlterTableAddColumnBuilder;
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
@@ -72,6 +72,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
     notNull(): AlterTableAddColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
     check(sql: string): AlterTableAddColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    stored(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -82,7 +84,7 @@ export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps
 export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
-    increments(): AlterTableModifyColumnBuilder;
+    autoIncrement(): AlterTableModifyColumnBuilder;
     primaryKey(): AlterTableModifyColumnBuilder;
     references(ref: string): AlterTableModifyColumnBuilder;
     onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
@@ -91,6 +93,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
     notNull(): AlterTableModifyColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
     check(sql: string): AlterTableModifyColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    stored(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/esm/schema/alter-table-builder.js

@@ -184,10 +184,10 @@ export class AlterTableAddColumnBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
-    increments() {
+    autoIncrement() {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.increments(),
+            columnBuilder: this.#props.columnBuilder.autoIncrement(),
         });
     }
     primaryKey() {
@@ -238,6 +238,18 @@ export class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
             addColumn: AddColumnNode.create(this.#props.columnBuilder.toOperationNode()),
@@ -255,10 +267,10 @@ export class AlterTableModifyColumnBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
-    increments() {
+    autoIncrement() {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.increments(),
+            columnBuilder: this.#props.columnBuilder.autoIncrement(),
         });
     }
     primaryKey() {
@@ -309,6 +321,18 @@ export class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
             modifyColumn: ModifyColumnNode.create(this.#props.columnBuilder.toOperationNode()),

package/dist/esm/schema/column-definition-builder.d.ts

@@ -12,7 +12,7 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * Some dialects like PostgreSQL don't support this. On PostgreSQL
      * you can use the `serial` or `bigserial` data type instead.
      */
-    increments(): R;
+    autoIncrement(): R;
     /**
      * Makes the column the primary key.
      *
@@ -40,10 +40,19 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
+     * @example
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
      */
     onDelete(onDelete: OnModifyForeignAction): R;
     /**
      * Adds an `on update` constraint for the foreign key column.
+     *
+     * @example
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
      */
     onUpdate(onUpdate: OnModifyForeignAction): R;
     /**
@@ -78,11 +87,41 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * ```
      */
     check(sql: string): R;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
+    generatedAlwaysAs(sql: string): R;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
+    stored(): R;
 }
 export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
     #private;
     constructor(node: ColumnDefinitionNode);
-    increments(): ColumnDefinitionBuilder;
+    autoIncrement(): ColumnDefinitionBuilder;
     primaryKey(): ColumnDefinitionBuilder;
     references(ref: string): ColumnDefinitionBuilder;
     onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
@@ -91,5 +130,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
     notNull(): ColumnDefinitionBuilder;
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     check(sql: string): ColumnDefinitionBuilder;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    stored(): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/esm/schema/column-definition-builder.js

@@ -6,16 +6,18 @@ import { parseStringReference } from '../parser/reference-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+import { GeneratedAlwaysAsNode } from '../operation-node/generated-always-as-node.js';
+import { DefaultValueNode } from '../operation-node/default-value-node.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
         this.#node = node;
     }
-    increments() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isAutoIncrementing: true }));
+    autoIncrement() {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));
     }
     primaryKey() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isPrimaryKey: true }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { primaryKey: true }));
     }
     references(ref) {
         const references = parseStringReference(ref);
@@ -45,14 +47,14 @@ export class ColumnDefinitionBuilder {
         }));
     }
     unique() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isUnique: true }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
     }
     notNull() {
-        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isNullable: false }));
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { nullable: false }));
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            defaultTo: parseDefaultValueExpression(value),
+            defaultTo: DefaultValueNode.create(parseDefaultValueExpression(value)),
         }));
     }
     check(sql) {
@@ -60,6 +62,21 @@ export class ColumnDefinitionBuilder {
             check: CheckConstraintNode.create(sql),
         }));
     }
+    generatedAlwaysAs(sql) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: GeneratedAlwaysAsNode.create(sql),
+        }));
+    }
+    stored() {
+        if (!this.#node.generatedAlwaysAs) {
+            throw new Error('stored() can only be called after generatedAlwaysAs');
+        }
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: GeneratedAlwaysAsNode.cloneWith(this.#node.generatedAlwaysAs, {
+                stored: true,
+            }),
+        }));
+    }
     toOperationNode() {
         return this.#node;
     }

package/dist/esm/schema/create-schema-builder.js

@@ -9,7 +9,7 @@ export class CreateSchemaBuilder {
     ifNotExists() {
         return new CreateSchemaBuilder({
             ...this.#props,
-            createSchemaNode: CreateSchemaNode.cloneWith(this.#props.createSchemaNode, { modifier: 'IfNotExists' }),
+            createSchemaNode: CreateSchemaNode.cloneWith(this.#props.createSchemaNode, { ifNotExists: true }),
         });
     }
     toOperationNode() {

package/dist/esm/schema/create-table-builder.d.ts

@@ -26,9 +26,9 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -37,11 +37,10 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

package/dist/esm/schema/create-table-builder.js

@@ -27,7 +27,7 @@ export class CreateTableBuilder {
     ifNotExists() {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: CreateTableNode.cloneWithModifier(this.#props.createTableNode, 'IfNotExists'),
+            createTableNode: CreateTableNode.cloneWithIfNotExists(this.#props.createTableNode, true),
         });
     }
     /**
@@ -37,9 +37,9 @@ export class CreateTableBuilder {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -48,11 +48,10 @@ export class CreateTableBuilder {
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

package/dist/esm/schema/create-view-builder.d.ts

@@ -0,0 +1,24 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+import { CreateViewNode } from '../operation-node/create-view-node.js';
+import { AnyQueryBuilder } from '../index.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
+export declare class CreateViewBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: CreateViewBuilderProps);
+    materialized(): CreateViewBuilder;
+    orReplace(): CreateViewBuilder;
+    columns(columns: string[]): CreateViewBuilder;
+    as(query: AnyQueryBuilder | AnyRawBuilder): CreateViewBuilder;
+    toOperationNode(): CreateViewNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface CreateViewBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createViewNode: CreateViewNode;
+}

package/dist/esm/schema/create-view-builder.js

@@ -0,0 +1,69 @@
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+import { CreateViewNode } from '../operation-node/create-view-node.js';
+import { parseColumnName } from '../parser/reference-parser.js';
+import { QueryNode } from '../index.js';
+import { ImmediateValuePlugin } from '../plugin/immediate-value.ts/immediate-value-plugin.js';
+export class CreateViewBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze({
+            ...props,
+            // The select statement (defined using the `as` method) can't have parameters on some
+            // dialects. We add the `ImmediateValuePlugin` to make all parameters "immediate"
+            // meaning they are interpolated into the SQL instead of added as parameters.
+            //
+            // The values are therefore not escaped at all, which leads to SQL injection
+            // vulnerabilities if user input is passed into the query. However, the use
+            // case where user input is passed into a `create view` statement is a weird
+            // one, and we can pretty safely just ignore it.
+            executor: props.executor.withPlugin(new ImmediateValuePlugin()),
+        });
+    }
+    materialized() {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
+                materialized: true,
+            }),
+        });
+    }
+    orReplace() {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
+                orReplace: true,
+            }),
+        });
+    }
+    columns(columns) {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
+                columns: columns.map(parseColumnName),
+            }),
+        });
+    }
+    as(query) {
+        const queryNode = query.toOperationNode();
+        if (QueryNode.isMutating(queryNode)) {
+            throw new Error('only select statements are allowd in views');
+        }
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: CreateViewNode.cloneWith(this.#props.createViewNode, {
+                as: queryNode,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.createViewNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+preventAwait(CreateViewBuilder, "don't await CreateViewBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-index-builder.js

@@ -23,7 +23,7 @@ export class DropIndexBuilder {
         return new DropIndexBuilder({
             ...this.#props,
             dropIndexNode: DropIndexNode.cloneWith(this.#props.dropIndexNode, {
-                modifier: 'IfExists',
+                ifExists: true,
             }),
         });
     }

package/dist/esm/schema/drop-schema-builder.js

@@ -9,7 +9,9 @@ export class DropSchemaBuilder {
     ifExists() {
         return new DropSchemaBuilder({
             ...this.#props,
-            dropSchemaNode: DropSchemaNode.cloneWithModifier(this.#props.dropSchemaNode, 'IfExists'),
+            dropSchemaNode: DropSchemaNode.cloneWith(this.#props.dropSchemaNode, {
+                ifExists: true,
+            }),
         });
     }
     toOperationNode() {

package/dist/esm/schema/drop-table-builder.js

@@ -9,7 +9,9 @@ export class DropTableBuilder {
     ifExists() {
         return new DropTableBuilder({
             ...this.#props,
-            dropTableNode: DropTableNode.cloneWithModifier(this.#props.dropTableNode, 'IfExists'),
+            dropTableNode: DropTableNode.cloneWith(this.#props.dropTableNode, {
+                ifExists: true,
+            }),
         });
     }
     toOperationNode() {

package/dist/esm/schema/drop-view-builder.d.ts

@@ -0,0 +1,20 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+import { DropViewNode } from '../operation-node/drop-view-node.js';
+export declare class DropViewBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: DropViewBuilderProps);
+    materialized(): DropViewBuilder;
+    ifExists(): DropViewBuilder;
+    toOperationNode(): DropViewNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface DropViewBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropViewNode: DropViewNode;
+}

package/dist/esm/schema/drop-view-builder.js

@@ -0,0 +1,35 @@
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+import { DropViewNode } from '../operation-node/drop-view-node.js';
+export class DropViewBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    materialized() {
+        return new DropViewBuilder({
+            ...this.#props,
+            dropViewNode: DropViewNode.cloneWith(this.#props.dropViewNode, {
+                materialized: true,
+            }),
+        });
+    }
+    ifExists() {
+        return new DropViewBuilder({
+            ...this.#props,
+            dropViewNode: DropViewNode.cloneWith(this.#props.dropViewNode, {
+                ifExists: true,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.dropViewNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+preventAwait(DropViewBuilder, "don't await DropViewBuilder instances directly. To execute the query you need to call `execute`");