kysely 0.23.0 → 0.23.2

package/dist/cjs/schema/schema.js

@@ -90,7 +90,7 @@ class SchemaModule {
         return new create_table_builder_js_1.CreateTableBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.create((0, table_parser_js_1.parseTable)(table)),
+            node: create_table_node_js_1.CreateTableNode.create((0, table_parser_js_1.parseTable)(table)),
         });
     }
     /**
@@ -108,7 +108,7 @@ class SchemaModule {
         return new drop_table_builder_js_1.DropTableBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            dropTableNode: drop_table_node_js_1.DropTableNode.create((0, table_parser_js_1.parseTable)(table)),
+            node: drop_table_node_js_1.DropTableNode.create((0, table_parser_js_1.parseTable)(table)),
         });
     }
     /**
@@ -128,7 +128,7 @@ class SchemaModule {
         return new create_index_builder_js_1.CreateIndexBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            createIndexNode: create_index_node_js_1.CreateIndexNode.create(indexName),
+            node: create_index_node_js_1.CreateIndexNode.create(indexName),
         });
     }
     /**
@@ -146,7 +146,7 @@ class SchemaModule {
         return new drop_index_builder_js_1.DropIndexBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            dropIndexNode: drop_index_node_js_1.DropIndexNode.create(indexName),
+            node: drop_index_node_js_1.DropIndexNode.create(indexName),
         });
     }
     /**
@@ -164,7 +164,7 @@ class SchemaModule {
         return new create_schema_builder_js_1.CreateSchemaBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            createSchemaNode: create_schema_node_js_1.CreateSchemaNode.create(schema),
+            node: create_schema_node_js_1.CreateSchemaNode.create(schema),
         });
     }
     /**
@@ -182,7 +182,7 @@ class SchemaModule {
         return new drop_schema_builder_js_1.DropSchemaBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            dropSchemaNode: drop_schema_node_js_1.DropSchemaNode.create(schema),
+            node: drop_schema_node_js_1.DropSchemaNode.create(schema),
         });
     }
     /**
@@ -222,7 +222,7 @@ class SchemaModule {
         return new create_view_builder_js_1.CreateViewBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            createViewNode: create_view_node_js_1.CreateViewNode.create(viewName),
+            node: create_view_node_js_1.CreateViewNode.create(viewName),
         });
     }
     /**
@@ -241,7 +241,7 @@ class SchemaModule {
         return new drop_view_builder_js_1.DropViewBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            dropViewNode: drop_view_node_js_1.DropViewNode.create(viewName),
+            node: drop_view_node_js_1.DropViewNode.create(viewName),
         });
     }
     /**
@@ -262,7 +262,7 @@ class SchemaModule {
         return new create_type_builder_js_1.CreateTypeBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            createTypeNode: create_type_node_js_1.CreateTypeNode.create((0, identifier_parser_js_1.parseSchemableIdentifier)(typeName)),
+            node: create_type_node_js_1.CreateTypeNode.create((0, identifier_parser_js_1.parseSchemableIdentifier)(typeName)),
         });
     }
     /**
@@ -283,7 +283,7 @@ class SchemaModule {
         return new drop_type_builder_js_1.DropTypeBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            dropTypeNode: drop_type_node_js_1.DropTypeNode.create((0, identifier_parser_js_1.parseSchemableIdentifier)(typeName)),
+            node: drop_type_node_js_1.DropTypeNode.create((0, identifier_parser_js_1.parseSchemableIdentifier)(typeName)),
         });
     }
     /**

package/dist/cjs/util/type-error.d.ts

@@ -0,0 +1,3 @@
+export interface KyselyTypeError<E extends string> {
+    readonly __kyselyTypeError__: E;
+}

package/dist/cjs/util/type-error.js

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

package/dist/esm/operation-node/on-conflict-node.d.ts

@@ -25,4 +25,6 @@ export declare const OnConflictNode: Readonly<{
     cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
     cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
     cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): OnConflictNode;
+    cloneWithoutIndexWhere(node: OnConflictNode): OnConflictNode;
+    cloneWithoutUpdateWhere(node: OnConflictNode): OnConflictNode;
 }>;

package/dist/esm/operation-node/on-conflict-node.js

@@ -51,4 +51,16 @@ export const OnConflictNode = freeze({
                 : WhereNode.create(operation),
         });
     },
+    cloneWithoutIndexWhere(node) {
+        return freeze({
+            ...node,
+            indexWhere: undefined,
+        });
+    },
+    cloneWithoutUpdateWhere(node) {
+        return freeze({
+            ...node,
+            updateWhere: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/query-node.d.ts

@@ -17,4 +17,5 @@ export declare const QueryNode: Readonly<{
     cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, operation: OperationNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
     cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
+    cloneWithoutWhere<T_4 extends FilterableQueryNode>(node: T_4): T_4;
 }>;

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

@@ -46,4 +46,10 @@ export const QueryNode = freeze({
                 : ReturningNode.create(selections),
         });
     },
+    cloneWithoutWhere(node) {
+        return freeze({
+            ...node,
+            where: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/select-query-node.d.ts

@@ -50,4 +50,8 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
     cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
+    cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -108,4 +108,28 @@ export const SelectQueryNode = freeze({
             explain,
         });
     },
+    cloneWithoutSelections(select) {
+        return freeze({
+            ...select,
+            selections: [],
+        });
+    },
+    cloneWithoutLimit(select) {
+        return freeze({
+            ...select,
+            limit: undefined,
+        });
+    },
+    cloneWithoutOffset(select) {
+        return freeze({
+            ...select,
+            offset: undefined,
+        });
+    },
+    cloneWithoutOrderBy(select) {
+        return freeze({
+            ...select,
+            orderBy: undefined,
+        });
+    },
 });

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

@@ -21,6 +21,7 @@ import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -408,6 +409,25 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -662,7 +682,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -719,6 +739,48 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    /**
+     * Asserts that query's output row type equals the given type `T`.
+     *
+     * This method can be used to simplify excessively complex types to make typescript happy
+     * and much faster.
+     *
+     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+     * for typescript and you get errors like this:
+     *
+     * ```
+     * error TS2589: Type instantiation is excessively deep and possibly infinite.
+     * ```
+     *
+     * In these case you can often use this method to help typescript a little bit. When you use this
+     * method to assert the output type of a query, Kysely can drop the complex output type that
+     * consists of multiple nested helper types and replace it with the simple asserted type.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('deleted_person', (qb) => qb
+     *     .deleteFrom('person')
+     *     .where('id', '=', person.id)
+     *     .returning('first_name')
+     *     .assertType<{ first_name: string }>()
+     *   )
+     *   .with('deleted_pet', (qb) => qb
+     *     .deleteFrom('pet')
+     *     .where('owner_id', '=', person.id)
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['deleted_person', 'deleted_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType<T extends O>(): O extends T ? DeleteQueryBuilder<DB, TB, T> : KyselyTypeError<`assertType() call failed: The type passed in is not equal to the output type of the query.`>;
     /**
      * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
      */

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

@@ -65,6 +65,12 @@ export class DeleteQueryBuilder {
             queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExists(arg)),
         });
     }
+    clearWhere() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
+        });
+    }
     innerJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
@@ -173,7 +179,7 @@ export class DeleteQueryBuilder {
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -241,6 +247,50 @@ export class DeleteQueryBuilder {
     castTo() {
         return new DeleteQueryBuilder(this.#props);
     }
+    /**
+     * Asserts that query's output row type equals the given type `T`.
+     *
+     * This method can be used to simplify excessively complex types to make typescript happy
+     * and much faster.
+     *
+     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+     * for typescript and you get errors like this:
+     *
+     * ```
+     * error TS2589: Type instantiation is excessively deep and possibly infinite.
+     * ```
+     *
+     * In these case you can often use this method to help typescript a little bit. When you use this
+     * method to assert the output type of a query, Kysely can drop the complex output type that
+     * consists of multiple nested helper types and replace it with the simple asserted type.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('deleted_person', (qb) => qb
+     *     .deleteFrom('person')
+     *     .where('id', '=', person.id)
+     *     .returning('first_name')
+     *     .assertType<{ first_name: string }>()
+     *   )
+     *   .with('deleted_pet', (qb) => qb
+     *     .deleteFrom('pet')
+     *     .where('owner_id', '=', person.id)
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['deleted_person', 'deleted_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType() {
+        return new DeleteQueryBuilder(this.#props);
+    }
     /**
      * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
      */

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

@@ -18,6 +18,7 @@ import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder
 import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
+import { KyselyTypeError } from '../util/type-error.js';
 export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable {
     #private;
     constructor(props: InsertQueryBuilderProps);
@@ -459,7 +460,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -517,6 +518,48 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * don't support your use case.
      */
     castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    /**
+     * Asserts that query's output row type equals the given type `T`.
+     *
+     * This method can be used to simplify excessively complex types to make typescript happy
+     * and much faster.
+     *
+     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+     * for typescript and you get errors like this:
+     *
+     * ```
+     * error TS2589: Type instantiation is excessively deep and possibly infinite.
+     * ```
+     *
+     * In these case you can often use this method to help typescript a little bit. When you use this
+     * method to assert the output type of a query, Kysely can drop the complex output type that
+     * consists of multiple nested helper types and replace it with the simple asserted type.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('new_person', (qb) => qb
+     *     .insertInto('person')
+     *     .values(person)
+     *     .returning('id')
+     *     .assertType<{ id: string }>()
+     *   )
+     *   .with('new_pet', (qb) => qb
+     *     .insertInto('pet')
+     *     .values({ owner_id: (eb) => eb.selectFrom('new_person').select('id'), ...pet })
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['new_person', 'new_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType<T extends O>(): O extends T ? InsertQueryBuilder<DB, TB, T> : KyselyTypeError<`assertType() call failed: The type passed in is not equal to the output type of the query.`>;
     /**
      * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
      */

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

@@ -322,7 +322,7 @@ export class InsertQueryBuilder {
      *
      * ### Examples
      *
-     * The next example uses a helper funtion `log` to log a query:
+     * The next example uses a helper function `log` to log a query:
      *
      * ```ts
      * function log<T extends Compilable>(qb: T): T {
@@ -391,6 +391,50 @@ export class InsertQueryBuilder {
     castTo() {
         return new InsertQueryBuilder(this.#props);
     }
+    /**
+     * Asserts that query's output row type equals the given type `T`.
+     *
+     * This method can be used to simplify excessively complex types to make typescript happy
+     * and much faster.
+     *
+     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+     * for typescript and you get errors like this:
+     *
+     * ```
+     * error TS2589: Type instantiation is excessively deep and possibly infinite.
+     * ```
+     *
+     * In these case you can often use this method to help typescript a little bit. When you use this
+     * method to assert the output type of a query, Kysely can drop the complex output type that
+     * consists of multiple nested helper types and replace it with the simple asserted type.
+     *
+     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
+     * structurally equal to the current type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .with('new_person', (qb) => qb
+     *     .insertInto('person')
+     *     .values(person)
+     *     .returning('id')
+     *     .assertType<{ id: string }>()
+     *   )
+     *   .with('new_pet', (qb) => qb
+     *     .insertInto('pet')
+     *     .values({ owner_id: (eb) => eb.selectFrom('new_person').select('id'), ...pet })
+     *     .returning(['name as pet_name', 'species'])
+     *     .assertType<{ pet_name: string, species: Species }>()
+     *   )
+     *   .selectFrom(['new_person', 'new_pet'])
+     *   .selectAll()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    assertType() {
+        return new InsertQueryBuilder(this.#props);
+    }
     /**
      * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
      */

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -339,6 +339,25 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * See {@link WhereInterface.orWhereNotExists} for more info.
      */
     orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictBuilder<DB, TB>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): OnConflictBuilder<DB, TB>;
     /**
      * Adds the "do nothing" conflict action.
      *
@@ -703,5 +722,24 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * See {@link WhereInterface.orWhereNotExists} for more info.
      */
     orWhereNotExists(arg: ExpressionOrFactory<DB, TB, any>): OnConflictUpdateBuilder<DB, TB>;
+    /**
+     * Clears all where clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .where('id','=',42)
+     *   .clearWhere()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearWhere(): OnConflictUpdateBuilder<DB, TB>;
     toOperationNode(): OnConflictNode;
 }

package/dist/esm/query-builder/on-conflict-builder.js

@@ -154,6 +154,12 @@ export class OnConflictBuilder {
             onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
+    clearWhere() {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithoutIndexWhere(this.#props.onConflictNode),
+        });
+    }
     /**
      * Adds the "do nothing" conflict action.
      *
@@ -312,6 +318,12 @@ export class OnConflictUpdateBuilder {
             onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExists(arg)),
         });
     }
+    clearWhere() {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithoutUpdateWhere(this.#props.onConflictNode),
+        });
+    }
     toOperationNode() {
         return this.#props.onConflictNode;
     }