kysely 0.23.5 → 0.24.1

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

@@ -1,26 +1,25 @@
 /// <reference types="./insert-query-builder.d.ts" />
-import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
-import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
+import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
+import { parseInsertExpression, } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { parseUpdateObject } from '../parser/update-set-parser.js';
+import { parseUpdateExpression, } from '../parser/update-set-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 import { InsertResult } from './insert-result.js';
-import { NoResultError } from './no-result-error.js';
+import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
 import { parseExpression, } from '../parser/expression-parser.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { OnConflictBuilder, } from './on-conflict-builder.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { ExplainNode } from '../operation-node/explain-node.js';
 export class InsertQueryBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
-    values(args) {
-        const [columns, values] = parseInsertObjectOrList(args);
+    values(insert) {
+        const [columns, values] = parseInsertExpression(insert);
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
@@ -293,18 +292,18 @@ export class InsertQueryBuilder {
      *   .onDuplicateKeyUpdate({ species: 'hamster' })
      * ```
      */
-    onDuplicateKeyUpdate(updates) {
+    onDuplicateKeyUpdate(update) {
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateObject(updates)),
+                onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateExpression(update)),
             }),
         });
     }
     returning(selection) {
         return new InsertQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(selection)),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection)),
         });
     }
     returningAll() {
@@ -314,7 +313,8 @@ export class InsertQueryBuilder {
         });
     }
     /**
-     * Simply calls the given function passing `this` as the only argument.
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
      *
      * If you want to conditionally call a method on `this`, see
      * the {@link $if} method.
@@ -440,7 +440,7 @@ export class InsertQueryBuilder {
      *   )
      *   .with('new_pet', (qb) => qb
      *     .insertInto('pet')
-     *     .values({ owner_id: (eb) => eb.selectFrom('new_person').select('id'), ...pet })
+     *     .values((eb) => ({ owner_id: eb.selectFrom('new_person').select('id'), ...pet }))
      *     .returning(['name as pet_name', 'species'])
      *     .$assertType<{ pet_name: string, species: Species }>()
      *   )
@@ -504,38 +504,30 @@ export class InsertQueryBuilder {
      * the query returned no result.
      *
      * By default an instance of {@link NoResultError} is thrown, but you can
-     * provide a custom error class as the only argument to throw a different
+     * provide a custom error class, or callback as the only argument to throw a different
      * error.
      */
     async executeTakeFirstOrThrow(errorConstructor = NoResultError) {
         const result = await this.executeTakeFirst();
         if (result === undefined) {
-            throw new errorConstructor(this.toOperationNode());
+            const error = isNoResultErrorConstructor(errorConstructor)
+                ? new errorConstructor(this.toOperationNode())
+                : errorConstructor(this.toOperationNode());
+            throw error;
         }
         return result;
     }
-    /**
-     * Executes query with `explain` statement before `insert` keyword.
-     *
-     * ```ts
-     * const explained = await db
-     *  .insertInto('person')
-     *  .values(values)
-     *  .explain('json')
-     * ```
-     *
-     * The generated SQL (MySQL):
-     *
-     * ```sql
-     * explain format=json insert into `person` (`id`, `first_name`, `last_name`) values (?, ?, ?) (?, ?, ?)
-     * ```
-     */
+    async *stream(chunkSize = 100) {
+        const compiledQuery = this.compile();
+        const stream = this.#props.executor.stream(compiledQuery, chunkSize, this.#props.queryId);
+        for await (const item of stream) {
+            yield* item.rows;
+        }
+    }
     async explain(format, options) {
         const builder = new InsertQueryBuilder({
             ...this.#props,
-            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                explain: ExplainNode.create(format, options?.toOperationNode()),
-            }),
+            queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options),
         });
         return await builder.execute();
     }

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

@@ -42,3 +42,6 @@ export class InsertResult {
         return this.#numInsertedOrUpdatedRows;
     }
 }
+for (const property of ['insertId', 'numInsertedOrUpdatedRows']) {
+    Object.defineProperty(InsertResult.prototype, property, { enumerable: true });
+}

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

@@ -4,6 +4,8 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { SqlBool } from '../util/type-utils.js';
+import { OnExpressionBuilder } from './deprecated-on-expression-builder.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: JoinBuilderProps);
@@ -14,16 +16,19 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.where} for documentation and examples.
      */
     on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
-    on(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
+    on(factory: OnExpressionFactory<DB, TB>): JoinBuilder<DB, TB>;
     on(expression: Expression<any>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link WhereInterface.orWhere} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhere} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
-    orOn(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
+    orOn(factory: OnExpressionFactory<DB, TB>): JoinBuilder<DB, TB>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
     orOn(expression: Expression<any>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef} but adds an item to the join's
@@ -33,46 +38,38 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      */
     onRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link WhereInterface.orWhereRef} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhereRef} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOnRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link WhereInterface.whereExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.whereExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     onExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link WhereInterface.whereNotExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.whereNotExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     onNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link WhereInterface.orWhereExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhereExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOnExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
-     * Just like {@link WhereInterface.orWhereNotExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Adds `on true`.
      */
     onTrue(): JoinBuilder<DB, TB>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): JoinNode;
 }
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
 }
+declare type OnExpressionFactory<DB, TB extends keyof DB> = (eb: OnExpressionBuilder<DB, TB>) => Expression<SqlBool> | OnExpressionBuilder<DB, TB>;
+export {};

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

@@ -1,7 +1,7 @@
 /// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseOn, parseReferentialFilter, } from '../parser/binary-operation-parser.js';
+import { parseOn, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
 import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -16,6 +16,9 @@ export class JoinBuilder {
             joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOn(args)),
         });
     }
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
@@ -31,26 +34,20 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialFilter(lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
     /**
-     * Just like {@link WhereInterface.orWhereRef} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhereRef} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferentialFilter(lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
     /**
-     * Just like {@link WhereInterface.whereExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.whereExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     onExists(arg) {
         return new JoinBuilder({
@@ -59,10 +56,7 @@ export class JoinBuilder {
         });
     }
     /**
-     * Just like {@link WhereInterface.whereNotExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.whereNotExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     onNotExists(arg) {
         return new JoinBuilder({
@@ -71,10 +65,7 @@ export class JoinBuilder {
         });
     }
     /**
-     * Just like {@link WhereInterface.orWhereExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhereExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOnExists(arg) {
         return new JoinBuilder({
@@ -83,10 +74,7 @@ export class JoinBuilder {
         });
     }
     /**
-     * Just like {@link WhereInterface.orWhereNotExists} but adds an item to the join's
-     * `on` clause instead.
-     *
-     * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orOnNotExists(arg) {
         return new JoinBuilder({
@@ -103,6 +91,13 @@ export class JoinBuilder {
             joinNode: JoinNode.cloneWithOn(this.#props.joinNode, RawNode.createWithSql('true')),
         });
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.joinNode;
     }

package/dist/esm/query-builder/no-result-error.d.ts

@@ -7,3 +7,4 @@ export declare class NoResultError extends Error {
     readonly node: QueryNode;
     constructor(node: QueryNode);
 }
+export declare function isNoResultErrorConstructor(fn: NoResultErrorConstructor | ((node: QueryNode) => Error)): fn is NoResultErrorConstructor;

package/dist/esm/query-builder/no-result-error.js

@@ -9,3 +9,6 @@ export class NoResultError extends Error {
         this.node = node;
     }
 }
+export function isNoResultErrorConstructor(fn) {
+    return Object.prototype.hasOwnProperty.call(fn, 'prototype');
+}