kysely 0.19.2 → 0.19.5

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

@@ -49,6 +49,7 @@ export declare class AlterTableBuilder {
      * is because you can only add one column per `ALTER TABLE` query.
      */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
+    dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;
@@ -419,3 +420,15 @@ export declare class AlterTableAddForeignKeyConstraintBuilder implements Foreign
 export interface AlterTableAddForeignKeyConstraintBuilderProps extends AlterTableBuilderProps {
     readonly constraintBuilder: ForeignKeyConstraintBuilder;
 }
+export declare class AlterTableDropConstraintBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableDropConstraintBuilderProps);
+    ifExists(): AlterTableDropConstraintBuilder;
+    cascade(): AlterTableDropConstraintBuilder;
+    restrict(): AlterTableDropConstraintBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableDropConstraintBuilderProps extends AlterTableBuilderProps {
+}

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

@@ -20,6 +20,7 @@ import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constrai
 import { ColumnNode } from '../operation-node/column-node.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 import { parseTable } from '../parser/table-parser.js';
+import { DropConstraintNode } from '../operation-node/drop-constraint-node.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -121,6 +122,14 @@ export class AlterTableBuilder {
             constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
         });
     }
+    dropConstraint(constraintName) {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: DropConstraintNode.create(constraintName),
+            }),
+        });
+    }
 }
 export class AlterColumnBuilder {
     #props;
@@ -424,9 +433,55 @@ export class AlterTableAddForeignKeyConstraintBuilder {
         await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
+export class AlterTableDropConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    ifExists() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: DropConstraintNode.cloneWith(this.#props.alterTableNode.dropConstraint, {
+                    ifExists: true,
+                }),
+            }),
+        });
+    }
+    cascade() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: DropConstraintNode.cloneWith(this.#props.alterTableNode.dropConstraint, {
+                    modifier: 'cascade',
+                }),
+            }),
+        });
+    }
+    restrict() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                dropConstraint: DropConstraintNode.cloneWith(this.#props.alterTableNode.dropConstraint, {
+                    modifier: 'restrict',
+                }),
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.alterTableNode, 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`");
+preventAwait(AlterTableDropConstraintBuilder, "don't await AlterTableDropConstraintBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/util/type-utils.d.ts

@@ -111,6 +111,9 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
+export declare type NullableValues<T> = {
+    [P in keyof T]: Nullable<T[P]>;
+};
 /**
  * Takes all properties from T1 and merges all properties from T2
  * that don't exist in T1 as optional properties.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.19.2",
+  "version": "0.19.5",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -45,19 +45,19 @@
     "@types/better-sqlite3": "^7.5.0",
     "@types/chai": "^4.3.1",
     "@types/chai-subset": "^1.3.3",
-    "@types/mocha": "^9.1.0",
+    "@types/mocha": "^9.1.1",
     "@types/pg": "^8.6.5",
-    "better-sqlite3": "^7.5.1",
+    "better-sqlite3": "^7.5.3",
     "chai": "^4.3.6",
     "chai-subset": "^1.6.0",
-    "esbuild": "^0.14.36",
-    "mocha": "^9.2.2",
+    "esbuild": "^0.14.47",
+    "mocha": "^10.0.0",
     "mysql2": "^2.3.3",
     "pg": "^8.7.3",
-    "playwright": "^1.21.0",
-    "prettier": "^2.6.2",
-    "tsd": "^0.20.0",
-    "typedoc": "^0.22.15",
-    "typescript": "4.6.3"
+    "playwright": "^1.22.2",
+    "prettier": "^2.7.1",
+    "tsd": "^0.21.0",
+    "typedoc": "^0.22.18",
+    "typescript": "4.7.4"
   }
 }

package/dist/cjs/query-builder/join-interface.d.ts

@@ -1,130 +0,0 @@
-import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
-import { FullJoinTableExpressionDatabase, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
-export interface JoinInterface<DB, TB extends keyof DB> {
-    /**
-     * Joins another table to the query using an inner join.
-     *
-     * ### Examples
-     *
-     * Simple usage by providing a table name and two columns to join:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   // `select` needs to come after the call to `innerJoin` so
-     *   // that you can select from the joined table.
-     *   .select('person.id', 'pet.name')
-     *   .execute()
-     *
-     * result[0].id
-     * result[0].name
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."id", "pet"."name"
-     * from "person"
-     * inner join "pet"
-     * on "pet"."owner_id" = "person"."id"
-     * ```
-     *
-     * You can give an alias for the joined table like this:
-     *
-     * ```ts
-     * await db.selectFrom('person')
-     *   .innerJoin('pet as p', 'p.owner_id', 'person.id')
-     *   .where('p.name', '=', 'Doggo')
-     *   .selectAll()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * inner join "pet" as "p"
-     * on "p"."owner_id" = "person"."id"
-     * where "p".name" = $1
-     * ```
-     *
-     * You can provide a function as the second argument to get a join
-     * builder for creating more complex joins. The join builder has a
-     * bunch of `on*` methods for building the `on` clause of the join.
-     * There's basically an equivalent for every `where` method
-     * (`on`, `onRef`, `onExists` etc.). You can do all the same things
-     * with the `on` method that you can with the corresponding `where`
-     * method. See the `where` method documentation for more examples.
-     *
-     * ```ts
-     * await db.selectFrom('person')
-     *   .innerJoin(
-     *     'pet',
-     *     (join) => join
-     *       .onRef('pet.owner_id', '=', 'person.id')
-     *       .on('pet.name', '=', 'Doggo')
-     *   )
-     *   .selectAll()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * inner join "pet"
-     * on "pet"."owner_id" = "person"."id"
-     * and "pet"."name" = $1
-     * ```
-     *
-     * You can join a subquery by providing a select query (or a callback)
-     * as the first argument:
-     *
-     * ```ts
-     * await db.selectFrom('person')
-     *   .innerJoin(
-     *     qb.selectFrom('pet')
-     *       .select(['owner_id', 'name'])
-     *       .where('name', '=', 'Doggo')
-     *       .as('doggos'),
-     *     'doggos.owner_id',
-     *     'person.id',
-     *   )
-     *   .selectAll()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * inner join (
-     *   select "owner_id", "name"
-     *   from "pet"
-     *   where "name" = $1
-     * ) as "doggos"
-     * on "doggos"."owner_id" = "person"."id"
-     * ```
-     */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
-     */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    /**
-     * Just like {@link innerJoin} but adds a right join instead of an inner join.
-     */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-    /**
-     * Just like {@link innerJoin} but adds a full join instead of an inner join.
-     */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-}

package/dist/cjs/query-builder/join-interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/query-builder/join-interface.d.ts

@@ -1,130 +0,0 @@
-import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
-import { FullJoinTableExpressionDatabase, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
-export interface JoinInterface<DB, TB extends keyof DB> {
-    /**
-     * Joins another table to the query using an inner join.
-     *
-     * ### Examples
-     *
-     * Simple usage by providing a table name and two columns to join:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   // `select` needs to come after the call to `innerJoin` so
-     *   // that you can select from the joined table.
-     *   .select('person.id', 'pet.name')
-     *   .execute()
-     *
-     * result[0].id
-     * result[0].name
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."id", "pet"."name"
-     * from "person"
-     * inner join "pet"
-     * on "pet"."owner_id" = "person"."id"
-     * ```
-     *
-     * You can give an alias for the joined table like this:
-     *
-     * ```ts
-     * await db.selectFrom('person')
-     *   .innerJoin('pet as p', 'p.owner_id', 'person.id')
-     *   .where('p.name', '=', 'Doggo')
-     *   .selectAll()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * inner join "pet" as "p"
-     * on "p"."owner_id" = "person"."id"
-     * where "p".name" = $1
-     * ```
-     *
-     * You can provide a function as the second argument to get a join
-     * builder for creating more complex joins. The join builder has a
-     * bunch of `on*` methods for building the `on` clause of the join.
-     * There's basically an equivalent for every `where` method
-     * (`on`, `onRef`, `onExists` etc.). You can do all the same things
-     * with the `on` method that you can with the corresponding `where`
-     * method. See the `where` method documentation for more examples.
-     *
-     * ```ts
-     * await db.selectFrom('person')
-     *   .innerJoin(
-     *     'pet',
-     *     (join) => join
-     *       .onRef('pet.owner_id', '=', 'person.id')
-     *       .on('pet.name', '=', 'Doggo')
-     *   )
-     *   .selectAll()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * inner join "pet"
-     * on "pet"."owner_id" = "person"."id"
-     * and "pet"."name" = $1
-     * ```
-     *
-     * You can join a subquery by providing a select query (or a callback)
-     * as the first argument:
-     *
-     * ```ts
-     * await db.selectFrom('person')
-     *   .innerJoin(
-     *     qb.selectFrom('pet')
-     *       .select(['owner_id', 'name'])
-     *       .where('name', '=', 'Doggo')
-     *       .as('doggos'),
-     *     'doggos.owner_id',
-     *     'person.id',
-     *   )
-     *   .selectAll()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * inner join (
-     *   select "owner_id", "name"
-     *   from "pet"
-     *   where "name" = $1
-     * ) as "doggos"
-     * on "doggos"."owner_id" = "person"."id"
-     * ```
-     */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
-     */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-    /**
-     * Just like {@link innerJoin} but adds a right join instead of an inner join.
-     */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-    /**
-     * Just like {@link innerJoin} but adds a full join instead of an inner join.
-     */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): JoinInterface<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): JoinInterface<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>>;
-}

package/dist/esm/query-builder/join-interface.js

@@ -1,2 +0,0 @@
-/// <reference types="./join-interface.d.ts" />
-export {};