kysely 0.7.1 → 0.7.5

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

@@ -1,15 +1,15 @@
 import { CreateTableNode } from '../operation-node/create-table-node.js';
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 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 { ColumnDefinitionBuilder } from './column-definition-builder.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryId } from '../util/query-id.js';
+import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
+import { DataTypeExpression } from '../parser/data-type-parser.js';
 export declare class CreateTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: CreateTableBuilderConstructorArgs);
+    constructor(props: CreateTableBuilderProps);
     /**
      * Adds the "if not exists" modifier.
      *
@@ -30,7 +30,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *   .addColumn('data', db.raw('customtype'))
      * ```
      */
-    addColumn(columnName: string, dataType: ColumnDataType | RawBuilder, build?: ColumnBuilderCallback): CreateTableBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnBuilderCallback): CreateTableBuilder;
     /**
      * Adds a primary key constraint for one or more columns.
      *
@@ -70,15 +70,27 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *   ['id'],
      * )
      * ```
+     *
+     * @example
+     * ```ts
+     * addForeignKeyConstraint(
+     *   'owner_id_foreign',
+     *   ['owner_id1', 'owner_id2'],
+     *   'person',
+     *   ['id1', 'id2'],
+     *   (cb) => cb.onDelete('cascade')
+     * )
+     * ```
      */
-    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): CreateTableBuilder;
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface CreateTableBuilderConstructorArgs {
-    queryId: QueryId;
-    createTableNode: CreateTableNode;
-    executor: QueryExecutor;
+export interface CreateTableBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createTableNode: CreateTableNode;
 }
-export declare type ColumnBuilderCallback = (tableBuilder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export declare type ColumnBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export declare type ForeignKeyConstraintBuilderCallback = (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder;

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

@@ -1,17 +1,17 @@
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { CreateTableNode } from '../operation-node/create-table-node.js';
-import { DataTypeNode, } from '../operation-node/data-type-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionBuilder } from './column-definition-builder.js';
+import { freeze } from '../util/object-utils.js';
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 export class CreateTableBuilder {
-    #queryId;
-    #createTableNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createTableNode = args.createTableNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     /**
      * Adds the "if not exists" modifier.
@@ -20,9 +20,8 @@ export class CreateTableBuilder {
      */
     ifNotExists() {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithModifier(this.#createTableNode, 'IfNotExists'),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithModifier(this.#props.createTableNode, 'IfNotExists'),
         });
     }
     /**
@@ -40,16 +39,13 @@ export class CreateTableBuilder {
      * ```
      */
     addColumn(columnName, dataType, build) {
-        let columnBuilder = new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, isOperationNodeSource(dataType)
-            ? dataType.toOperationNode()
-            : DataTypeNode.create(dataType)));
+        let columnBuilder = new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType)));
         if (build) {
             columnBuilder = build(columnBuilder);
         }
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithColumn(this.#createTableNode, columnBuilder.toOperationNode()),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithColumn(this.#props.createTableNode, columnBuilder.toOperationNode()),
         });
     }
     /**
@@ -62,9 +58,8 @@ export class CreateTableBuilder {
      */
     addPrimaryKeyConstraint(constraintName, columns) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithPrimaryKeyConstraint(this.#createTableNode, constraintName, columns),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithPrimaryKeyConstraint(this.#props.createTableNode, constraintName, columns),
         });
     }
     /**
@@ -77,9 +72,8 @@ export class CreateTableBuilder {
      */
     addUniqueConstraint(constraintName, columns) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithUniqueConstraint(this.#createTableNode, constraintName, columns),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithUniqueConstraint(this.#props.createTableNode, constraintName, columns),
         });
     }
     /**
@@ -92,9 +86,8 @@ export class CreateTableBuilder {
      */
     addCheckConstraint(constraintName, checkExpression) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithCheckConstraint(this.#createTableNode, constraintName, checkExpression),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithCheckConstraint(this.#props.createTableNode, constraintName, checkExpression),
         });
     }
     /**
@@ -109,22 +102,36 @@ export class CreateTableBuilder {
      *   ['id'],
      * )
      * ```
+     *
+     * @example
+     * ```ts
+     * addForeignKeyConstraint(
+     *   'owner_id_foreign',
+     *   ['owner_id1', 'owner_id2'],
+     *   'person',
+     *   ['id1', 'id2'],
+     *   (cb) => cb.onDelete('cascade')
+     * )
+     * ```
      */
-    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build) {
+        let builder = new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName));
+        if (build) {
+            builder = build(builder);
+        }
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithForeignKeyConstraint(this.#createTableNode, constraintName, columns, targetTable, targetColumns),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithForeignKeyConstraint(this.#props.createTableNode, builder.toOperationNode()),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#createTableNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.createTableNode, 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(CreateTableBuilder, "don't await CreateTableBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-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 DropIndexBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropIndexBuilderConstructorArgs);
+    constructor(props: DropIndexBuilderProps);
     /**
      * Specifies the table the index was created for. This is not needed
      * in all dialects.
@@ -17,8 +17,8 @@ export declare class DropIndexBuilder implements OperationNodeSource, Compilable
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropIndexBuilderConstructorArgs {
-    queryId: QueryId;
-    dropIndexNode: DropIndexNode;
-    executor: QueryExecutor;
+export interface DropIndexBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropIndexNode: DropIndexNode;
 }

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/dist/esm/transformers/with-schema-transformer.d.ts

@@ -22,9 +22,4 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
-    private transformRoot;
-    private collectTables;
-    private collectTablesFromTableExpressionNodes;
-    private collectTablesFromJoins;
-    private collectTablesFromTableExpressionNode;
 }

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

@@ -9,31 +9,31 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         this.#schema = schema;
     }
     transformSelectQuery(node) {
-        return this.transformRoot(node, (node) => super.transformSelectQuery(node));
+        return this.#transformRoot(node, (node) => super.transformSelectQuery(node));
     }
     transformInsertQuery(node) {
-        return this.transformRoot(node, (node) => super.transformInsertQuery(node));
+        return this.#transformRoot(node, (node) => super.transformInsertQuery(node));
     }
     transformUpdateQuery(node) {
-        return this.transformRoot(node, (node) => super.transformUpdateQuery(node));
+        return this.#transformRoot(node, (node) => super.transformUpdateQuery(node));
     }
     transformDeleteQuery(node) {
-        return this.transformRoot(node, (node) => super.transformDeleteQuery(node));
+        return this.#transformRoot(node, (node) => super.transformDeleteQuery(node));
     }
     transformCreateTable(node) {
-        return this.transformRoot(node, (node) => super.transformCreateTable(node));
+        return this.#transformRoot(node, (node) => super.transformCreateTable(node));
     }
     transformDropTable(node) {
-        return this.transformRoot(node, (node) => super.transformDropTable(node));
+        return this.#transformRoot(node, (node) => super.transformDropTable(node));
     }
     transformCreateIndex(node) {
-        return this.transformRoot(node, (node) => super.transformCreateIndex(node));
+        return this.#transformRoot(node, (node) => super.transformCreateIndex(node));
     }
     transformDropIndex(node) {
-        return this.transformRoot(node, (node) => super.transformDropIndex(node));
+        return this.#transformRoot(node, (node) => super.transformDropIndex(node));
     }
     transformAlterTable(node) {
-        return this.transformRoot(node, (node) => super.transformAlterTable(node));
+        return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }
     transformTable(node) {
         const transformed = super.transformTable(node);
@@ -48,8 +48,8 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
             },
         };
     }
-    transformRoot(node, transform) {
-        const tables = this.collectTables(node);
+    #transformRoot(node, transform) {
+        const tables = this.#collectTables(node);
         for (const table of tables) {
             this.#tables.add(table);
         }
@@ -59,33 +59,33 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         }
         return transformed;
     }
-    collectTables(node) {
+    #collectTables(node) {
         const tables = new Set();
         if ('from' in node && node.from) {
-            this.collectTablesFromTableExpressionNodes(node.from.froms, tables);
+            this.#collectTablesFromTableExpressionNodes(node.from.froms, tables);
         }
         if ('into' in node && node.into) {
-            this.collectTablesFromTableExpressionNode(node.into, tables);
+            this.#collectTablesFromTableExpressionNode(node.into, tables);
         }
         if ('table' in node && node.table) {
-            this.collectTablesFromTableExpressionNode(node.table, tables);
+            this.#collectTablesFromTableExpressionNode(node.table, tables);
         }
         if ('joins' in node && node.joins) {
-            this.collectTablesFromJoins(node.joins, tables);
+            this.#collectTablesFromJoins(node.joins, tables);
         }
         return tables;
     }
-    collectTablesFromTableExpressionNodes(nodes, tables) {
+    #collectTablesFromTableExpressionNodes(nodes, tables) {
         for (const node of nodes) {
-            this.collectTablesFromTableExpressionNode(node, tables);
+            this.#collectTablesFromTableExpressionNode(node, tables);
         }
     }
-    collectTablesFromJoins(nodes, tables) {
+    #collectTablesFromJoins(nodes, tables) {
         for (const node of nodes) {
-            this.collectTablesFromTableExpressionNode(node.table, tables);
+            this.#collectTablesFromTableExpressionNode(node.table, tables);
         }
     }
-    collectTablesFromTableExpressionNode(node, tables) {
+    #collectTablesFromTableExpressionNode(node, tables) {
         const table = TableNode.is(node)
             ? node
             : AliasNode.is(node) && TableNode.is(node.node)

package/package.json

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