kysely 0.19.9 → 0.19.12

package/README.md

@@ -15,7 +15,7 @@ Kysely makes sure you only refer to tables and columns that are visible to the p
 you're writing. The result type only has the selected columns with correct types and aliases. As an
 added bonus you get autocompletion for all that stuff.
 
-As you can see in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
+As shown in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
 the alias given to `pet.name` and add the `pet_name` column to the result row type. Kysely is able to infer
 column names, aliases and types from selected subqueries, joined subqueries, `with` statements and pretty
 much anything you can think of.
@@ -32,15 +32,21 @@ You can find a more thorough introduction [here](https://www.jakso.me/blog/kysel
 # Table of contents
 
 - [Installation](#installation)
+    - [3rd party dialects](#3rd-party-dialects)
 - [Minimal example](#minimal-example)
 - [Generating types](#generating-types)
 - [Query examples](#query-examples)
-- [Recipes](https://github.com/koskimas/kysely/tree/master/recipes)
+  - [Select queries](#select-queries)
+    - [Stream select query results](#stream-select-query-results)
+  - [Update queries](#update-queries)
+  - [Insert queries](#insert-queries)
+  - [Delete queries](#delete-queries)
 - [Migrations](#migrations)
+    - [PostgreSQL migration example](#postgresql-migration-example)
+    - [MySQL migration example](#mysql-migration-example)
 - [Deno](#deno)
 - [Browser](#browser)
-- [API reference](https://koskimas.github.io/kysely/index.html)
-- [Changelog](https://github.com/koskimas/kysely/releases)
+- [Why not just contribute to knex](#why-not-just-contribute-to-knex)
 
 # Installation
 
@@ -180,6 +186,48 @@ You can find examples of select queries in the documentation of the
 the [where method](https://koskimas.github.io/kysely/classes/SelectQueryBuilder.html#where)
 among other places.
 
+### Stream select query results
+
+*Currently only supported by `postgres` and `mysql` dialects.*
+
+```ts
+import { Pool } from 'pg'
+// or `import * as Cursor from 'pg-cursor'` depending on your tsconfig
+import Cursor from 'pg-cursor'
+import {
+    Kysely,
+    PostgresDialect,
+} from 'kysely'
+
+const db = new Kysely<Database>({
+    // PostgresDialect requires the Cursor dependency
+    dialect: new PostgresDialect({
+        pool: new Pool({
+            host: 'localhost',
+            database: 'kysely_test'
+        }),
+        cursor: Cursor
+    }),
+
+    // MysqlDialect doesn't require any special configuration
+})
+
+async function demo() {
+    for await (const male of db.selectFrom("person")
+        .selectAll()
+        .where("person.gender", "=", "male")
+        .stream()) {
+        console.log(`Hello mr. ${male.first_name}!`)
+
+        if (male.first_name === "John") {
+          // After this line the db connection is released and no more 
+          // rows are streamed from the database to the client
+          break;
+        }
+    }
+}
+```
+
 ## Update queries
 
 See the [set method](https://koskimas.github.io/kysely/classes/UpdateQueryBuilder.html#set) and the
@@ -213,10 +261,11 @@ export async function down(db: Kysely<any>): Promise<void> {
 }
 ```
 
-The `up` function is called when you update your database schema to next version and `down`
+The `up` function is called when you update your database schema to the next version and `down`
 when you go back to previous version. The only argument for the functions is an instance of
-`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. Migrations
-should never depend on the current code of your app because they need to work even when the app
+`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. 
+
+Migrations should never depend on the current code of your app because they need to work even when the app
 changes. Migrations need to be "frozen in time".
 
 The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)

package/dist/cjs/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/cjs/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/cjs/dialect/mysql/mysql-driver.js

@@ -124,6 +124,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/cjs/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/cjs/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/cjs/dialect/postgres/postgres-driver.js

@@ -21,7 +21,9 @@ 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
@@ -60,8 +62,10 @@ class PostgresDriver {
 exports.PostgresDriver = PostgresDriver;
 class PostgresConnection {
     #client;
-    constructor(client) {
+    #options;
+    constructor(client, options) {
         this.#client = client;
+        this.#options = options;
     }
     async executeQuery(compiledQuery) {
         try {
@@ -82,6 +86,24 @@ class PostgresConnection {
             throw (0, stack_trace_utils_js_1.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/cjs/dialect/sqlite/sqlite-driver.js

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

package/dist/cjs/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/cjs/driver/dummy-driver.js

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

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

@@ -41,7 +41,9 @@ __exportStar(require("./query-compiler/default-query-compiler.js"), exports);
 __exportStar(require("./query-compiler/compiled-query.js"), exports);
 __exportStar(require("./schema/schema.js"), exports);
 __exportStar(require("./schema/create-table-builder.js"), exports);
+__exportStar(require("./schema/create-type-builder.js"), exports);
 __exportStar(require("./schema/drop-table-builder.js"), exports);
+__exportStar(require("./schema/drop-type-builder.js"), exports);
 __exportStar(require("./schema/create-index-builder.js"), exports);
 __exportStar(require("./schema/drop-index-builder.js"), exports);
 __exportStar(require("./schema/create-schema-builder.js"), exports);
@@ -103,6 +105,7 @@ __exportStar(require("./operation-node/constraint-node.js"), exports);
 __exportStar(require("./operation-node/create-index-node.js"), exports);
 __exportStar(require("./operation-node/create-schema-node.js"), exports);
 __exportStar(require("./operation-node/create-table-node.js"), exports);
+__exportStar(require("./operation-node/create-type-node.js"), exports);
 __exportStar(require("./operation-node/create-view-node.js"), exports);
 __exportStar(require("./operation-node/data-type-node.js"), exports);
 __exportStar(require("./operation-node/default-value-node.js"), exports);
@@ -112,6 +115,7 @@ __exportStar(require("./operation-node/drop-constraint-node.js"), exports);
 __exportStar(require("./operation-node/drop-index-node.js"), exports);
 __exportStar(require("./operation-node/drop-schema-node.js"), exports);
 __exportStar(require("./operation-node/drop-table-node.js"), exports);
+__exportStar(require("./operation-node/drop-type-node.js"), exports);
 __exportStar(require("./operation-node/drop-view-node.js"), exports);
 __exportStar(require("./operation-node/filter-node.js"), exports);
 __exportStar(require("./operation-node/foreign-key-constraint-node.js"), exports);

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateTableNode = void 0;
+exports.CreateTableNode = exports.ON_COMMIT_ACTIONS = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+exports.ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop'];
 /**
  * @internal
  */

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+const value_list_node_js_1 = require("./value-list-node.js");
+const value_node_js_1 = require("./value-node.js");
+/**
+ * @internal
+ */
+exports.CreateTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CreateTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return (0, object_utils_js_1.freeze)({
+            ...createType,
+            enum: value_list_node_js_1.ValueListNode.create(values.map((value) => value_node_js_1.ValueNode.createImmediate(value))),
+        });
+    },
+});

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

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

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

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

package/dist/cjs/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;

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

@@ -102,6 +102,8 @@ class OperationNodeTransformer {
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
         SelectModifierNode: this.transformSelectModifier.bind(this),
+        CreateTypeNode: this.transformCreateType.bind(this),
+        DropTypeNode: this.transformDropType.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -242,6 +244,7 @@ class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
             ignore: node.ignore,
+            replace: node.replace,
         });
     }
     transformValues(node) {
@@ -603,6 +606,20 @@ class OperationNodeTransformer {
             rawModifier: this.transformNode(node.rawModifier),
         });
     }
+    transformCreateType(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'CreateTypeNode',
+            name: this.transformNode(node.name),
+            enum: this.transformNode(node.enum),
+        });
+    }
+    transformDropType(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'DropTypeNode',
+            name: this.transformNode(node.name),
+            ifExists: node.ifExists,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/cjs/operation-node/operation-node-visitor.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';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -138,4 +140,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;
     protected abstract visitSelectModifier(node: SelectModifierNode): void;
+    protected abstract visitCreateType(node: CreateTypeNode): void;
+    protected abstract visitDropType(node: DropTypeNode): void;
 }

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

@@ -75,6 +75,8 @@ class OperationNodeVisitor {
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),
         SelectModifierNode: this.visitSelectModifier.bind(this),
+        CreateTypeNode: this.visitCreateType.bind(this),
+        DropTypeNode: this.visitDropType.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,7 +1,9 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
-export declare type OnModifyForeignAction = 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default';
+import { ArrayItemType } from '../util/type-utils.js';
+export declare const ON_MODIFY_FOREIGN_ACTIONS: readonly ["no action", "restrict", "cascade", "set null", "set default"];
+export declare type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;