kysely 0.9.7 → 0.10.1

package/dist/cjs/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/cjs/schema/create-table-builder.js

@@ -30,7 +30,7 @@ class CreateTableBuilder {
     ifNotExists() {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithModifier(this.#props.createTableNode, 'IfNotExists'),
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithIfNotExists(this.#props.createTableNode, true),
         });
     }
     /**
@@ -40,9 +40,9 @@ 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) =>
@@ -51,11 +51,10 @@ 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/cjs/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/cjs/schema/create-view-builder.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateViewBuilder = void 0;
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const create_view_node_js_1 = require("../operation-node/create-view-node.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
+const index_js_1 = require("../index.js");
+const immediate_value_plugin_js_1 = require("../plugin/immediate-value.ts/immediate-value-plugin.js");
+class CreateViewBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.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 immediate_value_plugin_js_1.ImmediateValuePlugin()),
+        });
+    }
+    materialized() {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: create_view_node_js_1.CreateViewNode.cloneWith(this.#props.createViewNode, {
+                materialized: true,
+            }),
+        });
+    }
+    orReplace() {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: create_view_node_js_1.CreateViewNode.cloneWith(this.#props.createViewNode, {
+                orReplace: true,
+            }),
+        });
+    }
+    columns(columns) {
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: create_view_node_js_1.CreateViewNode.cloneWith(this.#props.createViewNode, {
+                columns: columns.map(reference_parser_js_1.parseColumnName),
+            }),
+        });
+    }
+    as(query) {
+        const queryNode = query.toOperationNode();
+        if (index_js_1.QueryNode.isMutating(queryNode)) {
+            throw new Error('only select statements are allowd in views');
+        }
+        return new CreateViewBuilder({
+            ...this.#props,
+            createViewNode: create_view_node_js_1.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);
+    }
+}
+exports.CreateViewBuilder = CreateViewBuilder;
+(0, prevent_await_js_1.preventAwait)(CreateViewBuilder, "don't await CreateViewBuilder instances directly. To execute the query you need to call `execute`");

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

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

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

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

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

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

package/dist/cjs/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/cjs/schema/drop-view-builder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropViewBuilder = void 0;
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const drop_view_node_js_1 = require("../operation-node/drop-view-node.js");
+class DropViewBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    materialized() {
+        return new DropViewBuilder({
+            ...this.#props,
+            dropViewNode: drop_view_node_js_1.DropViewNode.cloneWith(this.#props.dropViewNode, {
+                materialized: true,
+            }),
+        });
+    }
+    ifExists() {
+        return new DropViewBuilder({
+            ...this.#props,
+            dropViewNode: drop_view_node_js_1.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);
+    }
+}
+exports.DropViewBuilder = DropViewBuilder;
+(0, prevent_await_js_1.preventAwait)(DropViewBuilder, "don't await DropViewBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/schema/schema.d.ts

@@ -6,6 +6,8 @@ import { CreateTableBuilder } from './create-table-builder.js';
 import { DropIndexBuilder } from './drop-index-builder.js';
 import { DropSchemaBuilder } from './drop-schema-builder.js';
 import { DropTableBuilder } from './drop-table-builder.js';
+import { CreateViewBuilder } from './create-view-builder.js';
+import { DropViewBuilder } from './drop-view-builder.js';
 /**
  * Provides methods for building database schema.
  */
@@ -22,7 +24,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('first_name', 'varchar', col => col.notNull())
      *   .addColumn('last_name', 'varchar', col => col.notNull())
      *   .addColumn('gender', 'varchar')
@@ -38,7 +40,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer', col => col
      *     .references('person.id')
      *     .onDelete('cascade')
@@ -55,7 +57,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer')
      *   .addForeignKeyConstraint(
      *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],
@@ -135,6 +137,31 @@ export declare class SchemaModule {
      * ```
      */
     alterTable(table: string): AlterTableBuilder;
+    /**
+     * Create a new view.
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createView('dogs')
+     *   .orReplace()
+     *   .as(db.selectFrom('pet').selectAll().where('species', '=', 'dog'))
+     *   .execute()
+     * ```
+     */
+    createView(viewName: string): CreateViewBuilder;
+    /**
+     * Drop a view.
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .dropView('dogs')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropView(viewName: string): DropViewBuilder;
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/cjs/schema/schema.js

@@ -18,6 +18,10 @@ const drop_schema_builder_js_1 = require("./drop-schema-builder.js");
 const drop_table_builder_js_1 = require("./drop-table-builder.js");
 const query_id_js_1 = require("../util/query-id.js");
 const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
+const create_view_builder_js_1 = require("./create-view-builder.js");
+const create_view_node_js_1 = require("../operation-node/create-view-node.js");
+const drop_view_builder_js_1 = require("./drop-view-builder.js");
+const drop_view_node_js_1 = require("../operation-node/drop-view-node.js");
 /**
  * Provides methods for building database schema.
  */
@@ -36,7 +40,7 @@ class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('first_name', 'varchar', col => col.notNull())
      *   .addColumn('last_name', 'varchar', col => col.notNull())
      *   .addColumn('gender', 'varchar')
@@ -52,7 +56,7 @@ class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer', col => col
      *     .references('person.id')
      *     .onDelete('cascade')
@@ -69,7 +73,7 @@ class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('pet')
-     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
      *   .addColumn('owner_id', 'integer')
      *   .addForeignKeyConstraint(
      *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],
@@ -191,6 +195,43 @@ class SchemaModule {
             alterTableNode: alter_table_node_js_1.AlterTableNode.create(table),
         });
     }
+    /**
+     * Create a new view.
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createView('dogs')
+     *   .orReplace()
+     *   .as(db.selectFrom('pet').selectAll().where('species', '=', 'dog'))
+     *   .execute()
+     * ```
+     */
+    createView(viewName) {
+        return new create_view_builder_js_1.CreateViewBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            createViewNode: create_view_node_js_1.CreateViewNode.create(viewName),
+        });
+    }
+    /**
+     * Drop a view.
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .dropView('dogs')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropView(viewName) {
+        return new drop_view_builder_js_1.DropViewBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            dropViewNode: drop_view_node_js_1.DropViewNode.create(viewName),
+        });
+    }
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/cjs/util/performance-now.d.ts

@@ -0,0 +1 @@
+export declare function performanceNow(): number;

package/dist/cjs/util/performance-now.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performanceNow = void 0;
+const object_utils_js_1 = require("./object-utils.js");
+function performanceNow() {
+    if (typeof performance !== 'undefined' && (0, object_utils_js_1.isFunction)(performance.now)) {
+        return performance.now();
+    }
+    else {
+        return Date.now();
+    }
+}
+exports.performanceNow = performanceNow;

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

@@ -1,3 +1,4 @@
+import { performanceNow } from '../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
@@ -71,7 +72,7 @@ class RuntimeConnection {
         this.#log = log;
     }
     async executeQuery(compiledQuery) {
-        const startTime = process.hrtime.bigint();
+        const startTime = performanceNow();
         try {
             return await this.#connection.executeQuery(compiledQuery);
         }
@@ -97,8 +98,6 @@ class RuntimeConnection {
         }));
     }
     #calculateDurationMillis(startTime) {
-        const endTime = process.hrtime.bigint();
-        const durationNanos = Number(endTime - startTime);
-        return durationNanos / 1_000_000;
+        return performanceNow() - startTime;
     }
 }

package/dist/esm/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/esm/index.js

@@ -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/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

@@ -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/esm/operation-node/create-view-node.js

@@ -0,0 +1,22 @@
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CreateViewNode = freeze({
+    is(node) {
+        return node.kind === 'CreateViewNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateViewNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWith(createView, params) {
+        return freeze({
+            ...createView,
+            ...params,
+        });
+    },
+});

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,
+        });
+    },
+});