kysely 0.19.9 → 0.19.12

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

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

package/dist/cjs/schema/foreign-key-constraint-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForeignKeyConstraintBuilder = void 0;
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
+const on_modify_action_parser_js_1 = require("../parser/on-modify-action-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 class ForeignKeyConstraintBuilder {
     #node;
@@ -10,12 +11,12 @@ class ForeignKeyConstraintBuilder {
     }
     onDelete(onDelete) {
         return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
-            onDelete,
+            onDelete: (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onDelete),
         }));
     }
     onUpdate(onUpdate) {
         return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
-            onUpdate,
+            onUpdate: (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onUpdate),
         }));
     }
     toOperationNode() {

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

@@ -9,6 +9,8 @@ import { DropTableBuilder } from './drop-table-builder.js';
 import { CreateViewBuilder } from './create-view-builder.js';
 import { DropViewBuilder } from './drop-view-builder.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { CreateTypeBuilder } from './create-type-builder.js';
+import { DropTypeBuilder } from './drop-type-builder.js';
 /**
  * Provides methods for building database schema.
  */
@@ -170,6 +172,36 @@ export declare class SchemaModule {
      * ```
      */
     dropView(viewName: string): DropViewBuilder;
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName: string): CreateTypeBuilder;
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName: string): DropTypeBuilder;
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/cjs/schema/schema.js

@@ -22,6 +22,10 @@ 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");
+const create_type_builder_js_1 = require("./create-type-builder.js");
+const drop_type_builder_js_1 = require("./drop-type-builder.js");
+const create_type_node_js_1 = require("../operation-node/create-type-node.js");
+const drop_type_node_js_1 = require("../operation-node/drop-type-node.js");
 /**
  * Provides methods for building database schema.
  */
@@ -239,6 +243,48 @@ class SchemaModule {
             dropViewNode: drop_view_node_js_1.DropViewNode.create(viewName),
         });
     }
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName) {
+        return new create_type_builder_js_1.CreateTypeBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            createTypeNode: create_type_node_js_1.CreateTypeNode.create(viewName),
+        });
+    }
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName) {
+        return new drop_type_builder_js_1.DropTypeBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            dropTypeNode: drop_type_node_js_1.DropTypeNode.create(viewName),
+        });
+    }
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/cjs/util/deferred.d.ts

@@ -0,0 +1,7 @@
+export declare class Deferred<T> {
+    #private;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}

package/dist/cjs/util/deferred.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deferred = void 0;
+class Deferred {
+    #promise;
+    #resolve;
+    #reject;
+    constructor() {
+        this.#promise = new Promise((resolve, reject) => {
+            this.#reject = reject;
+            this.#resolve = resolve;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    resolve = (value) => {
+        if (this.#resolve) {
+            this.#resolve(value);
+        }
+    };
+    reject = (reason) => {
+        if (this.#reject) {
+            this.#reject(reason);
+        }
+    };
+}
+exports.Deferred = Deferred;

package/dist/esm/dialect/mysql/mysql-dialect-config.d.ts

@@ -31,9 +31,19 @@ export interface MysqlPool {
     end(callback: (error: unknown) => void): void;
 }
 export interface MysqlPoolConnection {
+    query(sql: string, parameters: ReadonlyArray<unknown>): {
+        stream: <T>(options: MysqlStreamOptions) => MysqlStream<T>;
+    };
     query(sql: string, parameters: ReadonlyArray<unknown>, callback: (error: unknown, result: MysqlQueryResult) => void): void;
     release(): void;
 }
+export interface MysqlStreamOptions {
+    highWaterMark?: number;
+    objectMode?: boolean;
+}
+export interface MysqlStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
 export interface MysqlOkPacket {
     affectedRows: number;
     insertId: number;

package/dist/esm/dialect/mysql/mysql-driver.d.ts

@@ -42,6 +42,7 @@ declare class MysqlConnection implements DatabaseConnection {
     #private;
     constructor(rawConnection: MysqlPoolConnection);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

package/dist/esm/dialect/mysql/mysql-driver.js

@@ -121,6 +121,31 @@ class MysqlConnection {
             });
         });
     }
+    async *streamQuery(compiledQuery, chunkSize) {
+        const stream = this.#rawConnection
+            .query(compiledQuery.sql, compiledQuery.parameters)
+            .stream({
+            objectMode: true,
+        });
+        try {
+            for await (const row of stream) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        catch (ex) {
+            if (ex &&
+                typeof ex === 'object' &&
+                'code' in ex &&
+                // @ts-ignore
+                ex.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                // Most likely because of https://github.com/mysqljs/mysql/blob/master/lib/protocol/sequences/Query.js#L220
+                return;
+            }
+            throw ex;
+        }
+    }
     [PRIVATE_RELEASE_METHOD]() {
         this.#rawConnection.release();
     }

package/dist/esm/dialect/postgres/postgres-dialect-config.d.ts

@@ -1,4 +1,14 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
+export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: readonly unknown[]) => PostgresCursor<T>;
+export declare type PostgresCursor<T> = {
+    state: 'initialized' | 'idle' | 'submitted' | 'busy';
+    read: (rowsCount: number) => Promise<T[]>;
+} | {
+    state: 'done';
+} | {
+    state: 'error';
+    _error: Error;
+};
 /**
  * Config for the PostgreSQL dialect.
  */
@@ -11,6 +21,19 @@ export interface PostgresDialectConfig {
      * https://node-postgres.com/api/pool
      */
     pool: PostgresPool | (() => Promise<PostgresPool>);
+    /**
+     * https://github.com/brianc/node-postgres/tree/master/packages/pg-cursor
+     * ```ts
+     * import Cursor from 'pg-cursor'
+     * // or
+     * import * as Cursor from 'pg-cursor'
+     *
+     * new PostgresDialect({
+     *  cursor: Cursor
+     * })
+     * ```
+     */
+    cursor?: PostgresCursorConstructor;
     /**
      * Called once for each created connection.
      */
@@ -30,6 +53,7 @@ export interface PostgresPool {
 }
 export interface PostgresPoolClient {
     query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
+    query<R>(cursor: PostgresCursor<R>): PostgresCursor<R>;
     release(): void;
 }
 export interface PostgresQueryResult<R> {
@@ -37,3 +61,8 @@ export interface PostgresQueryResult<R> {
     rowCount: number;
     rows: R[];
 }
+export interface PostgresStreamOptions {
+}
+export interface PostgresStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/dist/esm/dialect/postgres/postgres-driver.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
+import { PostgresCursorConstructor, PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
 declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class PostgresDriver implements Driver {
     #private;
@@ -38,10 +38,14 @@ export declare class PostgresDriver implements Driver {
      */
     destroy(): Promise<void>;
 }
+interface PostgresConnectionOptions {
+    cursor: PostgresCursorConstructor | null;
+}
 declare class PostgresConnection implements DatabaseConnection {
     #private;
-    constructor(client: PostgresPoolClient);
+    constructor(client: PostgresPoolClient, options: PostgresConnectionOptions);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -19,7 +19,9 @@ export class PostgresDriver {
         const client = await this.#pool.connect();
         let connection = this.#connections.get(client);
         if (!connection) {
-            connection = new PostgresConnection(client);
+            connection = new PostgresConnection(client, {
+                cursor: this.#config.cursor ?? null,
+            });
             this.#connections.set(client, connection);
             // The driver must take care of calling `onCreateConnection` when a new
             // connection is created. The `pg` module doesn't provide an async hook
@@ -57,8 +59,10 @@ export class PostgresDriver {
 }
 class PostgresConnection {
     #client;
-    constructor(client) {
+    #options;
+    constructor(client, options) {
         this.#client = client;
+        this.#options = options;
     }
     async executeQuery(compiledQuery) {
         try {
@@ -79,6 +83,24 @@ class PostgresConnection {
             throw extendStackTrace(err, new Error());
         }
     }
+    async *streamQuery(compiledQuery, chunkSize) {
+        if (!this.#options.cursor) {
+            throw new Error("'cursor' is not present in your postgres dialect config. It's required to make streaming work in postgres.");
+        }
+        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters));
+        while (true) {
+            if (cursor.state === 'done') {
+                break;
+            }
+            if (cursor.state === 'error') {
+                throw cursor._error;
+            }
+            const rows = await cursor.read(chunkSize);
+            yield {
+                rows,
+            };
+        }
+    }
     [PRIVATE_RELEASE_METHOD]() {
         this.#client.release();
     }

package/dist/esm/dialect/sqlite/sqlite-driver.js

@@ -66,6 +66,9 @@ class SqliteConnection {
             });
         }
     }
+    async *streamQuery() {
+        throw new Error("Sqlite driver doesn't support streaming");
+    }
 }
 class ConnectionMutex {
     #promise;

package/dist/esm/driver/database-connection.d.ts

@@ -6,6 +6,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
  */
 export interface DatabaseConnection {
     executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
 }
 export interface QueryResult<O> {
     /**

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

@@ -64,4 +64,7 @@ class DummyConnection {
             rows: [],
         };
     }
+    async *streamQuery() {
+        // Nothing to do here.
+    }
 }

package/dist/esm/index.d.ts

@@ -25,7 +25,9 @@ export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/compiled-query.js';
 export * from './schema/schema.js';
 export * from './schema/create-table-builder.js';
+export * from './schema/create-type-builder.js';
 export * from './schema/drop-table-builder.js';
+export * from './schema/drop-type-builder.js';
 export * from './schema/create-index-builder.js';
 export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
@@ -87,6 +89,7 @@ export * from './operation-node/constraint-node.js';
 export * from './operation-node/create-index-node.js';
 export * from './operation-node/create-schema-node.js';
 export * from './operation-node/create-table-node.js';
+export * from './operation-node/create-type-node.js';
 export * from './operation-node/create-view-node.js';
 export * from './operation-node/data-type-node.js';
 export * from './operation-node/default-value-node.js';
@@ -96,6 +99,7 @@ export * from './operation-node/drop-constraint-node.js';
 export * from './operation-node/drop-index-node.js';
 export * from './operation-node/drop-schema-node.js';
 export * from './operation-node/drop-table-node.js';
+export * from './operation-node/drop-type-node.js';
 export * from './operation-node/drop-view-node.js';
 export * from './operation-node/filter-node.js';
 export * from './operation-node/foreign-key-constraint-node.js';

package/dist/esm/index.js

@@ -26,7 +26,9 @@ export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/compiled-query.js';
 export * from './schema/schema.js';
 export * from './schema/create-table-builder.js';
+export * from './schema/create-type-builder.js';
 export * from './schema/drop-table-builder.js';
+export * from './schema/drop-type-builder.js';
 export * from './schema/create-index-builder.js';
 export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
@@ -88,6 +90,7 @@ export * from './operation-node/constraint-node.js';
 export * from './operation-node/create-index-node.js';
 export * from './operation-node/create-schema-node.js';
 export * from './operation-node/create-table-node.js';
+export * from './operation-node/create-type-node.js';
 export * from './operation-node/create-view-node.js';
 export * from './operation-node/data-type-node.js';
 export * from './operation-node/default-value-node.js';
@@ -97,6 +100,7 @@ export * from './operation-node/drop-constraint-node.js';
 export * from './operation-node/drop-index-node.js';
 export * from './operation-node/drop-schema-node.js';
 export * from './operation-node/drop-table-node.js';
+export * from './operation-node/drop-type-node.js';
 export * from './operation-node/drop-view-node.js';
 export * from './operation-node/filter-node.js';
 export * from './operation-node/foreign-key-constraint-node.js';

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

@@ -2,7 +2,9 @@ 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 OnCommitAction = 'preserve rows' | 'delete rows' | 'drop';
+import { ArrayItemType } from '../util/type-utils.js';
+export declare const ON_COMMIT_ACTIONS: string[];
+export declare type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
 export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints'>;
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';

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

@@ -1,5 +1,6 @@
 /// <reference types="./create-table-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+export const ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop'];
 /**
  * @internal
  */

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

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: IdentifierNode;
+    readonly enum?: ValueListNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: string): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+}>;

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

@@ -0,0 +1,25 @@
+/// <reference types="./create-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+import { ValueListNode } from './value-list-node.js';
+import { ValueNode } from './value-node.js';
+/**
+ * @internal
+ */
+export const CreateTypeNode = freeze({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateTypeNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return freeze({
+            ...createType,
+            enum: ValueListNode.create(values.map((value) => ValueNode.createImmediate(value))),
+        });
+    },
+});

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

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
+export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
 export declare type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';

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

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

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

@@ -0,0 +1,23 @@
+/// <reference types="./drop-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const DropTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'DropTypeNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropType, params) {
+        return freeze({
+            ...dropType,
+            ...params,
+        });
+    },
+});

package/dist/esm/operation-node/foreign-key-constraint-node.d.ts

@@ -20,8 +20,8 @@ export declare const ForeignKeyConstraintNode: Readonly<{
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
     cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
         name?: IdentifierNode | undefined;
-        onDelete?: OnModifyForeignAction | undefined;
-        onUpdate?: OnModifyForeignAction | undefined;
+        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
+        onUpdate?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
         kind: 'ForeignKeyConstraintNode';
         columns: ReadonlyArray<ColumnNode>;
         references: ReferencesNode;

package/dist/esm/operation-node/insert-query-node.d.ts

@@ -19,12 +19,13 @@ export interface InsertQueryNode extends OperationNode {
     readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
     readonly ignore?: boolean;
+    readonly replace?: boolean;
 }
 /**
  * @internal
  */
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
-    create(into: TableNode, withNode?: WithNode): InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/esm/operation-node/insert-query-node.js

@@ -7,11 +7,12 @@ export const InsertQueryNode = freeze({
     is(node) {
         return node.kind === 'InsertQueryNode';
     },
-    create(into, withNode) {
+    create(into, withNode, replace) {
         return freeze({
             kind: 'InsertQueryNode',
             into,
             ...(withNode && { with: withNode }),
+            replace,
         });
     },
     cloneWith(insertQuery, props) {

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

@@ -66,6 +66,8 @@ import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -162,6 +164,8 @@ export declare class OperationNodeTransformer {
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
     protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;