kysely 0.7.2 → 0.7.6

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

@@ -1,14 +1,11 @@
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { parseTable } from '../parser/table-parser.js';
+import { freeze } from '../util/object-utils.js';
 export class DropIndexBuilder {
-    #queryId;
-    #dropIndexNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropIndexNode = args.dropIndexNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     /**
      * Specifies the table the index was created for. This is not needed
@@ -16,30 +13,28 @@ export class DropIndexBuilder {
      */
     on(table) {
         return new DropIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropIndexNode: DropIndexNode.cloneWith(this.#dropIndexNode, {
+            ...this.#props,
+            dropIndexNode: DropIndexNode.cloneWith(this.#props.dropIndexNode, {
                 table: parseTable(table),
             }),
         });
     }
     ifExists() {
         return new DropIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropIndexNode: DropIndexNode.cloneWith(this.#dropIndexNode, {
+            ...this.#props,
+            dropIndexNode: DropIndexNode.cloneWith(this.#props.dropIndexNode, {
                 modifier: 'IfExists',
             }),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropIndexNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropIndexNode, 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(DropIndexBuilder, "don't await DropIndexBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-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 DropSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropSchemaBuilderConstructorArgs);
+    constructor(props: DropSchemaBuilderProps);
     ifExists(): DropSchemaBuilder;
     toOperationNode(): DropSchemaNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropSchemaBuilderConstructorArgs {
-    queryId: QueryId;
-    dropSchemaNode: DropSchemaNode;
-    executor: QueryExecutor;
+export interface DropSchemaBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropSchemaNode: DropSchemaNode;
 }

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

@@ -1,29 +1,25 @@
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
 import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
 export class DropSchemaBuilder {
-    #queryId;
-    #dropSchemaNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropSchemaNode = args.dropSchemaNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     ifExists() {
         return new DropSchemaBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropSchemaNode: DropSchemaNode.cloneWithModifier(this.#dropSchemaNode, 'IfExists'),
+            ...this.#props,
+            dropSchemaNode: DropSchemaNode.cloneWithModifier(this.#props.dropSchemaNode, 'IfExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropSchemaNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropSchemaNode, 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(DropSchemaBuilder, "don't await DropSchemaBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-table-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 DropTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropTableBuilderConstructorArgs);
+    constructor(props: DropTableBuilderProps);
     ifExists(): DropTableBuilder;
     toOperationNode(): DropTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropTableBuilderConstructorArgs {
-    queryId: QueryId;
-    dropTableNode: DropTableNode;
-    executor: QueryExecutor;
+export interface DropTableBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropTableNode: DropTableNode;
 }

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

@@ -1,29 +1,25 @@
 import { DropTableNode } from '../operation-node/drop-table-node.js';
 import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
 export class DropTableBuilder {
-    #queryId;
-    #dropTableNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropTableNode = args.dropTableNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     ifExists() {
         return new DropTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropTableNode: DropTableNode.cloneWithModifier(this.#dropTableNode, 'IfExists'),
+            ...this.#props,
+            dropTableNode: DropTableNode.cloneWithModifier(this.#props.dropTableNode, 'IfExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropTableNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropTableNode, 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(DropTableBuilder, "don't await DropTableBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/foreign-key-constraint-builder.d.ts

@@ -0,0 +1,14 @@
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
+export interface ForeignKeyConstraintBuilderInterface<R> {
+    onDelete(onDelete: OnModifyForeignAction): R;
+    onUpdate(onUpdate: OnModifyForeignAction): R;
+}
+export declare class ForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<ForeignKeyConstraintBuilder>, OperationNodeSource {
+    #private;
+    constructor(node: ForeignKeyConstraintNode);
+    onDelete(onDelete: OnModifyForeignAction): ForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): ForeignKeyConstraintBuilder;
+    toOperationNode(): ForeignKeyConstraintNode;
+}

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

@@ -0,0 +1,22 @@
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+export class ForeignKeyConstraintBuilder {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    onDelete(onDelete) {
+        return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, {
+            onDelete,
+        }));
+    }
+    onUpdate(onUpdate) {
+        return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, {
+            onUpdate,
+        }));
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+preventAwait(ForeignKeyConstraintBuilder, "don't await ForeignKeyConstraintBuilder instances directly.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.7.2",
+  "version": "0.7.6",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",