kysely 0.19.9 → 0.19.12

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

@@ -100,6 +100,8 @@ export 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) {
@@ -240,6 +242,7 @@ export class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
             ignore: node.ignore,
+            replace: node.replace,
         });
     }
     transformValues(node) {
@@ -601,6 +604,20 @@ export class OperationNodeTransformer {
             rawModifier: this.transformNode(node.rawModifier),
         });
     }
+    transformCreateType(node) {
+        return requireAllProps({
+            kind: 'CreateTypeNode',
+            name: this.transformNode(node.name),
+            enum: this.transformNode(node.enum),
+        });
+    }
+    transformDropType(node) {
+        return 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/esm/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/esm/operation-node/operation-node-visitor.js

@@ -73,6 +73,8 @@ export 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/esm/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/esm/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;

package/dist/esm/operation-node/references-node.js

@@ -1,5 +1,12 @@
 /// <reference types="./references-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+export const ON_MODIFY_FOREIGN_ACTIONS = [
+    'no action',
+    'restrict',
+    'cascade',
+    'set null',
+    'set default',
+];
 /**
  * @internal
  */

package/dist/esm/parser/on-commit-action-parse.d.ts

@@ -0,0 +1,2 @@
+import { OnCommitAction } from '../operation-node/create-table-node.js';
+export declare function parseOnCommitAction(action: OnCommitAction): OnCommitAction;

package/dist/esm/parser/on-commit-action-parse.js

@@ -0,0 +1,8 @@
+/// <reference types="./on-commit-action-parse.d.ts" />
+import { ON_COMMIT_ACTIONS, } from '../operation-node/create-table-node.js';
+export function parseOnCommitAction(action) {
+    if (ON_COMMIT_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnCommitAction ${action}`);
+}

package/dist/esm/parser/on-modify-action-parser.d.ts

@@ -0,0 +1,2 @@
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
+export declare function parseOnModifyForeignAction(action: OnModifyForeignAction): OnModifyForeignAction;

package/dist/esm/parser/on-modify-action-parser.js

@@ -0,0 +1,8 @@
+/// <reference types="./on-modify-action-parser.d.ts" />
+import { ON_MODIFY_FOREIGN_ACTIONS, } from '../operation-node/references-node.js';
+export function parseOnModifyForeignAction(action) {
+    if (ON_MODIFY_FOREIGN_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnModifyForeignAction ${action}`);
+}

package/dist/esm/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,10 +1,12 @@
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { CreateTableNode } from '../../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../../operation-node/create-type-node.js';
 import { CreateViewNode } from '../../operation-node/create-view-node.js';
 import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../../operation-node/drop-index-node.js';
 import { DropTableNode } from '../../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../../operation-node/drop-type-node.js';
 import { DropViewNode } from '../../operation-node/drop-view-node.js';
 import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
@@ -24,6 +26,8 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -39,6 +39,12 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
     transformDropView(node) {
         return this.#transformRoot(node, (node) => super.transformDropView(node));
     }
+    transformCreateType(node) {
+        return this.#transformRoot(node, (node) => super.transformCreateType(node));
+    }
+    transformDropType(node) {
+        return this.#transformRoot(node, (node) => super.transformDropType(node));
+    }
     transformAlterTable(node) {
         return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }

package/dist/esm/query-builder/insert-query-builder.d.ts

@@ -43,7 +43,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * Insert a row into `person`:
      * ```ts
-     * const id = await db
+     * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',

package/dist/esm/query-builder/select-query-builder.d.ts

@@ -1343,6 +1343,33 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * error.
      */
     executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db.
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    stream(chunkSize?: number): AsyncIterableIterator<O>;
 }
 export interface SelectQueryBuilderProps {
     readonly queryId: QueryId;

package/dist/esm/query-builder/select-query-builder.js

@@ -1,5 +1,6 @@
 /// <reference types="./select-query-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
+import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
@@ -14,7 +15,6 @@ import { parseGroupBy } from '../parser/group-by-parser.js';
 import { parseUnion } from '../parser/union-parser.js';
 import { NoResultError } from './no-result-error.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 export class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -628,7 +628,6 @@ export class SelectQueryBuilder {
      */
     async execute() {
         const compildQuery = this.compile();
-        const query = compildQuery.query;
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
         return result.rows;
     }
@@ -655,6 +654,39 @@ export class SelectQueryBuilder {
         }
         return result;
     }
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db.
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    async *stream(chunkSize = 100) {
+        const compildQuery = this.compile();
+        const stream = this.#props.executor.stream(compildQuery, chunkSize, this.#props.queryId);
+        for await (const item of stream) {
+            yield* item.rows;
+        }
+    }
 }
 preventAwait(SelectQueryBuilder, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
 /**

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

@@ -69,6 +69,8 @@ import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -145,11 +147,14 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
     protected visitSelectModifier(node: SelectModifierNode): void;
+    protected visitCreateType(node: CreateTypeNode): void;
+    protected visitDropType(node: DropTypeNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
+    protected sanitizeIdentifier(identifier: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
 }

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

@@ -132,7 +132,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append('insert');
+        this.append(node.replace ? 'replace' : 'insert');
         if (node.ignore) {
             this.append(' ignore');
         }
@@ -225,7 +225,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(this.getRightIdentifierWrapper());
     }
     compileUnwrappedIdentifier(node) {
-        this.append(node.identifier);
+        this.append(this.sanitizeIdentifier(node.identifier));
     }
     visitFilter(node) {
         if (node.left) {
@@ -789,6 +789,21 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(SELECT_MODIFIER_SQL[node.modifier]);
         }
     }
+    visitCreateType(node) {
+        this.append('create type ');
+        this.visitNode(node.name);
+        if (node.enum) {
+            this.append(' as enum ');
+            this.visitNode(node.enum);
+        }
+    }
+    visitDropType(node) {
+        this.append('drop type ');
+        if (node.ifExists) {
+            this.append('if exists ');
+        }
+        this.visitNode(node.name);
+    }
     append(str) {
         this.#sql += str;
     }
@@ -805,6 +820,24 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     getCurrentParameterPlaceholder() {
         return '$' + this.numParameters;
     }
+    sanitizeIdentifier(identifier) {
+        if (!isString(identifier)) {
+            throw new Error('a non-string identifier was passed to sanitizeIdentifier.');
+        }
+        const leftWrap = this.getLeftIdentifierWrapper();
+        const rightWrap = this.getRightIdentifierWrapper();
+        let sanitized = '';
+        for (const c of identifier) {
+            sanitized += c;
+            if (c === leftWrap) {
+                sanitized += leftWrap;
+            }
+            else if (c === rightWrap) {
+                sanitized += rightWrap;
+            }
+        }
+        return sanitized;
+    }
     addParameter(parameter) {
         this.#parameters.push(parameter);
     }

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

@@ -2,15 +2,17 @@ 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 { CreateTypeNode } from '../operation-node/create-type-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 { DropTypeNode } from '../operation-node/drop-type-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 | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode;
+export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

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

@@ -161,6 +161,33 @@ export declare class QueryCreator<DB> {
      * ```
      */
     insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
      * Creates a delete query.
      *

package/dist/esm/query-creator.js

@@ -70,6 +70,39 @@ export class QueryCreator {
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto(table) {
+        return new InsertQueryBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true),
+        });
+    }
     /**
      * Creates a delete query.
      *

package/dist/esm/query-executor/query-executor-base.d.ts

@@ -36,6 +36,12 @@ export declare abstract class QueryExecutorBase implements QueryExecutor {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */

package/dist/esm/query-executor/query-executor-base.js

@@ -1,5 +1,6 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { Deferred } from '../util/deferred.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
     #plugins;
@@ -34,6 +35,24 @@ export class QueryExecutorBase {
             return this.#transformResult(result, queryId);
         });
     }
+    async *stream(compiledQuery, chunkSize, queryId) {
+        const connectionDefer = new Deferred();
+        const connectionReleaseDefer = new Deferred();
+        this.provideConnection(async (connection) => {
+            connectionDefer.resolve(connection);
+            // Lets wait until we don't need connection before returning here (returning releases connection)
+            return await connectionReleaseDefer.promise;
+        }).catch((ex) => connectionDefer.reject(ex));
+        const connection = await connectionDefer.promise;
+        try {
+            for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
+                yield await this.#transformResult(result, queryId);
+            }
+        }
+        finally {
+            connectionReleaseDefer.resolve();
+        }
+    }
     async #transformResult(result, queryId) {
         for (const plugin of this.#plugins) {
             result = await plugin.transformResult({ result, queryId });

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

@@ -37,6 +37,17 @@ export interface QueryExecutor extends ConnectionProvider {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, 
+    /**
+     * How many rows should be pulled from the database at once. Supported
+     * only by the postgres driver.
+     */
+    chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */

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

@@ -9,6 +9,7 @@ import { ColumnDefinitionNode } from '../operation-node/column-definition-node.j
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 import { GeneratedNode } from '../operation-node/generated-node.js';
 import { DefaultValueNode } from '../operation-node/default-value-node.js';
+import { parseOnModifyForeignAction } from '../parser/on-modify-action-parser.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -36,7 +37,7 @@ export class ColumnDefinitionBuilder {
             throw new Error('on delete constraint can only be added for foreign keys');
         }
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            references: ReferencesNode.cloneWithOnDelete(this.#node.references, onDelete),
+            references: ReferencesNode.cloneWithOnDelete(this.#node.references, parseOnModifyForeignAction(onDelete)),
         }));
     }
     onUpdate(onUpdate) {
@@ -44,7 +45,7 @@ export class ColumnDefinitionBuilder {
             throw new Error('on update constraint can only be added for foreign keys');
         }
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            references: ReferencesNode.cloneWithOnUpdate(this.#node.references, onUpdate),
+            references: ReferencesNode.cloneWithOnUpdate(this.#node.references, parseOnModifyForeignAction(onUpdate)),
         }));
     }
     unique() {

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

@@ -47,17 +47,17 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', sql`customtype`)
+     *   .addColumn('data', sql`some_type`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
      * ```
      *
-     * With this method, it's once again good to remember that Kysely just builds the query
-     * 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:
+     * With this method, it's once again good to remember that Kysely just builds the
+     * query and doesn't provide the same API for all databses. For example, some
+     * databases like older MySQL don't support the `references` statement in the
+     * column definition. Instead foreign key constraints need to be defined in the
+     * `create table` query. See the next example:
      *
      * ```ts
      *   .addColumn('parent_id', 'integer')

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

@@ -12,6 +12,7 @@ import { PrimaryConstraintNode } from '../operation-node/primary-constraint-node
 import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js';
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
 import { parseTable } from '../parser/table-parser.js';
+import { parseOnCommitAction } from '../parser/on-commit-action-parse.js';
 /**
  * This builder can be used to create a `create table` query.
  */
@@ -43,7 +44,7 @@ export class CreateTableBuilder {
         return new CreateTableBuilder({
             ...this.#props,
             createTableNode: CreateTableNode.cloneWith(this.#props.createTableNode, {
-                onCommit,
+                onCommit: parseOnCommitAction(onCommit),
             }),
         });
     }
@@ -74,17 +75,17 @@ export class CreateTableBuilder {
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', sql`customtype`)
+     *   .addColumn('data', sql`some_type`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
      * ```
      *
-     * With this method, it's once again good to remember that Kysely just builds the query
-     * 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:
+     * With this method, it's once again good to remember that Kysely just builds the
+     * query and doesn't provide the same API for all databses. For example, some
+     * databases like older MySQL don't support the `references` statement in the
+     * column definition. Instead foreign key constraints need to be defined in the
+     * `create table` query. See the next example:
      *
      * ```ts
      *   .addColumn('parent_id', 'integer')

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

@@ -0,0 +1,28 @@
+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 { CreateTypeNode } from '../operation-node/create-type-node.js';
+export declare class CreateTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: CreateTypeBuilderProps);
+    toOperationNode(): CreateTypeNode;
+    /**
+     * Creates an anum type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createType('species').asEnum(['cat', 'dog', 'frog'])
+     * ```
+     */
+    asEnum(values: string[]): CreateTypeBuilder;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface CreateTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createTypeNode: CreateTypeNode;
+}