kysely 0.7.1 → 0.7.5

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

@@ -2,7 +2,7 @@ import { DataTypeNode } from '../operation-node/data-type-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { isEmpty, getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
+import { getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sqlFragments = [];
     #bindings = [];
@@ -32,7 +32,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append('select ');
-        if (node.distinctOnSelections && !isEmpty(node.distinctOnSelections)) {
+        if (node.distinctOnSelections) {
             this.compileDistinctOn(node.distinctOnSelections);
             this.append(' ');
         }
@@ -118,8 +118,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append(this.getInsertInto(node));
-        this.append(' ');
+        this.append('insert');
+        if (node.ignore) {
+            this.append(' ignore');
+        }
+        this.append(' into ');
         this.visitNode(node.into);
         if (node.columns) {
             this.append(' (');
@@ -134,6 +137,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.onConflict);
         }
+        if (node.onDuplicateKey) {
+            this.append(' ');
+            this.visitNode(node.onDuplicateKey);
+        }
         if (node.returning) {
             this.append(' ');
             this.visitNode(node.returning);
@@ -142,9 +149,6 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(')');
         }
     }
-    getInsertInto(node) {
-        return 'insert into';
-    }
     visitDeleteQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
         if (isSubQuery) {
@@ -330,6 +334,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on delete ');
             this.append(node.onDelete);
         }
+        if (node.onUpdate) {
+            this.append(' on update ');
+            this.append(node.onUpdate);
+        }
     }
     visitDropTable(node) {
         this.append('drop table ');
@@ -420,6 +428,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileList(node.updates);
         }
     }
+    visitOnDuplicateKey(node) {
+        this.append('on duplicate key update ');
+        this.compileList(node.updates);
+    }
     visitCreateIndex(node) {
         this.append('create ');
         if (node.unique) {
@@ -512,6 +524,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.compileList(node.columns);
         this.append(') ');
         this.visitNode(node.references);
+        if (node.onDelete) {
+            this.append(' on delete ');
+            this.append(node.onDelete);
+        }
+        if (node.onUpdate) {
+            this.append(' on update ');
+            this.append(node.onUpdate);
+        }
     }
     visitList(node) {
         this.compileList(node.items);

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

@@ -5,7 +5,7 @@ import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
-import { DialectAdapter } from './index.js';
+import { ParseContext } from './parser/parse-context.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -378,7 +378,7 @@ export declare class QueryCreator<DB> {
     raw<T = unknown>(sql: string, params?: any[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
-    readonly adapter: DialectAdapter;
     readonly executor: QueryExecutor;
+    readonly parseContext: ParseContext;
     readonly withNode?: WithNode;
 }

package/dist/esm/query-creator.js

@@ -10,7 +10,6 @@ import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
 import { freeze } from './util/object-utils.js';
-import { createParseContext } from './parser/parse-context.js';
 export class QueryCreator {
     #props;
     constructor(props) {
@@ -20,8 +19,8 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#parseContext, from), this.#props.withNode),
+            parseContext: this.#props.parseContext,
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#props.parseContext, from), this.#props.withNode),
         });
     }
     /**
@@ -69,7 +68,7 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
+            parseContext: this.#props.parseContext,
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
@@ -91,8 +90,8 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: DeleteQueryNode.create(parseTableExpression(this.#parseContext, table), this.#props.withNode),
+            parseContext: this.#props.parseContext,
+            queryNode: DeleteQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
         });
     }
     /**
@@ -117,8 +116,8 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: UpdateQueryNode.create(parseTableExpression(this.#parseContext, table), this.#props.withNode),
+            parseContext: this.#props.parseContext,
+            queryNode: UpdateQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
         });
     }
     /**
@@ -144,7 +143,7 @@ export class QueryCreator {
      * ```
      */
     with(name, expression) {
-        const cte = parseCommonTableExpression(this.#parseContext, name, expression);
+        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -322,7 +321,4 @@ export class QueryCreator {
             executor: this.#props.executor,
         });
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }

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

@@ -2,15 +2,16 @@ import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { OnDelete } from '../operation-node/references-node.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { Compilable } from '../util/compilable.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
 import { AnyRawBuilder } from '../query-builder/type-utils.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
+import { DataTypeExpression } from '../parser/data-type-parser.js';
+import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
 export declare class AlterTableBuilder {
     #private;
     constructor(props: AlterTableBuilderProps);
@@ -19,8 +20,16 @@ export declare class AlterTableBuilder {
     alterColumn(column: string): AlterColumnBuilder;
     dropColumn(column: string): AlterTableExecutor;
     renameColumn(column: string, newColumn: string): AlterTableExecutor;
-    addColumn(columnName: string, dataType: ColumnDataType | RawBuilder): AlterTableAddColumnBuilder;
-    modifyColumn(columnName: string, dataType: ColumnDataType | RawBuilder): AlterTableModifyColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression): AlterTableAddColumnBuilder;
+    /**
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
+     */
+    modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
+    addCheckConstraint(constraintName: string, checkExpression: string): AlterTableExecutor;
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;
@@ -48,13 +57,14 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder> {
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
     increments(): AlterTableAddColumnBuilder;
     primaryKey(): AlterTableAddColumnBuilder;
     references(ref: string): AlterTableAddColumnBuilder;
-    onDelete(onDelete: OnDelete): AlterTableAddColumnBuilder;
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
     unique(): AlterTableAddColumnBuilder;
     notNull(): AlterTableAddColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
@@ -66,13 +76,14 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
 export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder> {
+export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
     increments(): AlterTableModifyColumnBuilder;
     primaryKey(): AlterTableModifyColumnBuilder;
     references(ref: string): AlterTableModifyColumnBuilder;
-    onDelete(onDelete: OnDelete): AlterTableModifyColumnBuilder;
+    onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
     unique(): AlterTableModifyColumnBuilder;
     notNull(): AlterTableModifyColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
@@ -84,3 +95,15 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
 export interface AlterTableModifyColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
+export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableAddForeignKeyConstraintBuilderProps extends AlterTableBuilderProps {
+    readonly constraintBuilder: ForeignKeyConstraintBuilder;
+}

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

@@ -13,6 +13,13 @@ import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionBuilder, } from './column-definition-builder.js';
 import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
+import { ForeignKeyConstraintBuilder, } from './foreign-key-constraint-builder.js';
+import { AddConstraintNode } from '../operation-node/add-constraint-node.js';
+import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js';
+import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
 export class AlterTableBuilder {
     #props;
     constructor(props) {
@@ -59,17 +66,40 @@ export class AlterTableBuilder {
     addColumn(columnName, dataType) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, isOperationNodeSource(dataType)
-                ? dataType.toOperationNode()
-                : DataTypeNode.create(dataType))),
+            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))),
         });
     }
+    /**
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
+     */
     modifyColumn(columnName, dataType) {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
-            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, isOperationNodeSource(dataType)
-                ? dataType.toOperationNode()
-                : DataTypeNode.create(dataType))),
+            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))),
+        });
+    }
+    addUniqueConstraint(constraintName, columns) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                addConstraint: AddConstraintNode.create(UniqueConstraintNode.create(columns, constraintName)),
+            }),
+        });
+    }
+    addCheckConstraint(constraintName, checkExpression) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                addConstraint: AddConstraintNode.create(CheckConstraintNode.create(checkExpression, constraintName)),
+            }),
+        });
+    }
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
         });
     }
 }
@@ -175,6 +205,12 @@ export class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.onDelete(onDelete),
         });
     }
+    onUpdate(onDelete) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.onUpdate(onDelete),
+        });
+    }
     unique() {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -240,6 +276,12 @@ export class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.onDelete(onDelete),
         });
     }
+    onUpdate(onUpdate) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.onUpdate(onUpdate),
+        });
+    }
     unique() {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
@@ -276,8 +318,38 @@ export class AlterTableModifyColumnBuilder {
         await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
+export class AlterTableAddForeignKeyConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
+        });
+    }
+    onUpdate(onUpdate) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
+            addConstraint: AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
+        }), this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
 preventAwait(AlterTableBuilder, "don't await AlterTableBuilder instances");
 preventAwait(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 preventAwait(AlterTableExecutor, "don't await AlterTableExecutor instances directly. To execute the query you need to call `execute`");
 preventAwait(AlterTableAddColumnBuilder, "don't await AlterTableAddColumnBuilder instances directly. To execute the query you need to call `execute`");
 preventAwait(AlterTableModifyColumnBuilder, "don't await AlterTableModifyColumnBuilder instances directly. To execute the query you need to call `execute`");
+preventAwait(AlterTableAddForeignKeyConstraintBuilder, "don't await AlterTableAddForeignKeyConstraintBuilder instances directly. To execute the query you need to call `execute`");

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

@@ -1,8 +1,9 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { OnDelete } from '../operation-node/references-node.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * Makes the column automatically incrementing.
@@ -31,7 +32,11 @@ export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * Adds an `on delete` constraint for the foreign key column.
      */
-    onDelete(onDelete: OnDelete): R;
+    onDelete(onDelete: OnModifyForeignAction): R;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     */
+    onUpdate(onUpdate: OnModifyForeignAction): R;
     /**
      * Adds a unique constraint for the column.
      */
@@ -71,10 +76,11 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
     increments(): ColumnDefinitionBuilder;
     primaryKey(): ColumnDefinitionBuilder;
     references(ref: string): ColumnDefinitionBuilder;
-    onDelete(onDelete: OnDelete): ColumnDefinitionBuilder;
+    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder;
     unique(): ColumnDefinitionBuilder;
     notNull(): ColumnDefinitionBuilder;
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilder;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     check(sql: string): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

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

@@ -1,12 +1,11 @@
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { ReferencesNode } from '../operation-node/references-node.js';
+import { ReferencesNode, } from '../operation-node/references-node.js';
 import { SelectAllNode } from '../operation-node/select-all-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
 import { parseStringReference } from '../parser/reference-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
+import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -37,6 +36,14 @@ export class ColumnDefinitionBuilder {
             references: ReferencesNode.cloneWithOnDelete(this.#node.references, onDelete),
         }));
     }
+    onUpdate(onUpdate) {
+        if (!this.#node.references) {
+            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),
+        }));
+    }
     unique() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isUnique: true }));
     }
@@ -45,9 +52,7 @@ export class ColumnDefinitionBuilder {
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            defaultTo: isOperationNodeSource(value)
-                ? value.toOperationNode()
-                : ValueNode.createImmediate(value),
+            defaultTo: parseDefaultValueExpression(value),
         }));
     }
     check(sql) {
@@ -59,4 +64,4 @@ export class ColumnDefinitionBuilder {
         return this.#node;
     }
 }
-preventAwait(ColumnDefinitionBuilder, "don't await ColumnBuilder instances directly.");
+preventAwait(ColumnDefinitionBuilder, "don't await ColumnDefinitionBuilder instances directly.");

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

@@ -6,7 +6,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: CreateIndexBuilderConstructorArgs);
+    constructor(props: CreateIndexBuilderProps);
     /**
      * Makes the index unique.
      */
@@ -49,8 +49,8 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface CreateIndexBuilderConstructorArgs {
-    queryId: QueryId;
-    createIndexNode: CreateIndexNode;
-    executor: QueryExecutor;
+export interface CreateIndexBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createIndexNode: CreateIndexNode;
 }

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

@@ -4,23 +4,19 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { parseColumnName } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
 export class CreateIndexBuilder {
-    #queryId;
-    #createIndexNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createIndexNode = args.createIndexNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     /**
      * Makes the index unique.
      */
     unique() {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 unique: true,
             }),
         });
@@ -30,9 +26,8 @@ export class CreateIndexBuilder {
      */
     on(table) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 table: parseTable(table),
             }),
         });
@@ -44,9 +39,8 @@ export class CreateIndexBuilder {
      */
     column(column) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 expression: parseColumnName(column),
             }),
         });
@@ -58,9 +52,8 @@ export class CreateIndexBuilder {
      */
     columns(columns) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 expression: ListNode.create(columns.map(parseColumnName)),
             }),
         });
@@ -79,30 +72,28 @@ export class CreateIndexBuilder {
      */
     expression(expression) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 expression: RawNode.createWithSql(expression),
             }),
         });
     }
     using(indexType) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 using: RawNode.createWithSql(indexType),
             }),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#createIndexNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.createIndexNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 preventAwait(CreateIndexBuilder, "don't await CreateIndexBuilder instances directly. To execute the query you need to call `execute`");

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

@@ -6,14 +6,14 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class CreateSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: CreateSchemaBuilderConstructorArgs);
+    constructor(props: CreateSchemaBuilderProps);
     ifNotExists(): CreateSchemaBuilder;
     toOperationNode(): CreateSchemaNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface CreateSchemaBuilderConstructorArgs {
-    queryId: QueryId;
-    createSchemaNode: CreateSchemaNode;
-    executor: QueryExecutor;
+export interface CreateSchemaBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createSchemaNode: CreateSchemaNode;
 }

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

@@ -1,29 +1,25 @@
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
 export class CreateSchemaBuilder {
-    #queryId;
-    #createSchemaNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createSchemaNode = args.createSchemaNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     ifNotExists() {
         return new CreateSchemaBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createSchemaNode: CreateSchemaNode.cloneWithModifier(this.#createSchemaNode, 'IfNotExists'),
+            ...this.#props,
+            createSchemaNode: CreateSchemaNode.cloneWithModifier(this.#props.createSchemaNode, 'IfNotExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#createSchemaNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.createSchemaNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 preventAwait(CreateSchemaBuilder, "don't await CreateSchemaBuilder instances directly. To execute the query you need to call `execute`");