apply executable @ select.

Author: igalklebanov

src/query-builder/select-query-builder.ts

@@ -30,7 +30,6 @@ import {
   Nullable,
   ShallowRecord,
   Simplify,
-  SimplifySingleResult,
   SqlBool,
 } from '../util/type-utils.js'
 import {
@@ -83,9 +82,11 @@ import { TopModifier } from '../operation-node/top-node.js'
 import { parseTop } from '../parser/top-parser.js'
 import { JoinType } from '../operation-node/join-node.js'
 import { OrderByInterface } from './order-by-interface.js'
+import { Executable, ExecuteOptions } from '../util/executable.js'
 
 export interface SelectQueryBuilder<DB, TB extends keyof DB, O>
-  extends WhereInterface<DB, TB>,
+  extends Executable<Simplify<O>>,
+    WhereInterface<DB, TB>,
     HavingInterface<DB, TB>,
     OrderByInterface<DB, TB, O>,
     SelectQueryBuilderExpression<O>,
@@ -2117,31 +2118,20 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O>
 
   compile(): CompiledQuery<Simplify<O>>
 
-  /**
-   * Executes the query and returns an array of rows.
-   *
-   * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
-   */
   execute(): Promise<Simplify<O>[]>
 
-  /**
-   * Executes the query and returns the first result or undefined if
-   * the query returned no result.
-   */
-  executeTakeFirst(): Promise<SimplifySingleResult<O>>
+  executeTakeFirst(): Promise<Simplify<O> | undefined>
 
-  /**
-   * Executes the query and returns the first result or throws if
-   * the query returned no result.
-   *
-   * By default an instance of {@link NoResultError} is thrown, but you can
-   * provide a custom error class, or callback to throw a different
-   * error.
-   */
   executeTakeFirstOrThrow(
     errorConstructor?: NoResultErrorConstructor | ((node: QueryNode) => Error),
   ): Promise<Simplify<O>>
 
+  executeTakeFirstOrThrow(
+    options?: ExecuteOptions & {
+      errorConstructor?: NoResultErrorConstructor | ((node: QueryNode) => Error)
+    },
+  ): Promise<O>
+
   stream(chunkSize?: number): AsyncIterableIterator<O>
 
   explain<ER extends Record<string, any> = Record<string, any>>(
@@ -2647,35 +2637,43 @@ class SelectQueryBuilderImpl<DB, TB extends keyof DB, O>
     )
   }
 
-  async execute(): Promise<Simplify<O>[]> {
+  async execute(options?: any): Promise<any> {
     const compiledQuery = this.compile()
 
-    const result = await this.#props.executor.executeQuery<O>(compiledQuery)
+    const result = await this.#props.executor.executeQuery<O>(
+      compiledQuery,
+      options,
+    )
 
     return result.rows
   }
 
-  async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
-    const [result] = await this.execute()
-    return result as SimplifySingleResult<O>
+  async executeTakeFirst(options?: any): Promise<any> {
+    const [result] = await this.execute(options)
+    return result
   }
 
-  async executeTakeFirstOrThrow(
-    errorConstructor:
-      | NoResultErrorConstructor
-      | ((node: QueryNode) => Error) = NoResultError,
-  ): Promise<Simplify<O>> {
-    const result = await this.executeTakeFirst()
+  async executeTakeFirstOrThrow(errorConstructorOrOptions?: any): Promise<any> {
+    if (typeof errorConstructorOrOptions === 'function') {
+      errorConstructorOrOptions = {
+        errorConstructor: errorConstructorOrOptions,
+      }
+    }
+
+    const result = await this.executeTakeFirst(errorConstructorOrOptions)
 
     if (result === undefined) {
+      const errorConstructor =
+        errorConstructorOrOptions?.errorConstructor ?? NoResultError
+
       const error = isNoResultErrorConstructor(errorConstructor)
         ? new errorConstructor(this.toOperationNode())
         : errorConstructor(this.toOperationNode())
 
       throw error
     }
 
-    return result as O
+    return result
   }
 
   async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {

src/query-executor/query-executor.ts

@@ -44,7 +44,10 @@ export interface QueryExecutor extends ConnectionProvider {
    * Executes a compiled query and runs the result through all plugins'
    * `transformResult` method.
    */
-  executeQuery<R>(compiledQuery: CompiledQuery<R>): Promise<QueryResult<R>>
+  executeQuery<R>(
+    compiledQuery: CompiledQuery<R>,
+    options?: ExecuteQueryOptions,
+  ): Promise<QueryResult<R>>
 
   /**
    * Executes a compiled query and runs the result through all plugins'
@@ -88,3 +91,16 @@ export interface QueryExecutor extends ConnectionProvider {
    */
   withoutPlugins(): QueryExecutor
 }
+
+export interface ExecuteQueryOptions {
+  /**
+   * An optional signal that can be used to abort the execution of the query.
+   *
+   * This is useful for cancelling long-running queries, for example when
+   * the user navigates away from the page or closes the browser tab.
+   *
+   * Writes (insert, update, delete) are not cancellable in most database engines,
+   * so this signal is mostly useful for read queries.
+   */
+  abortSignal?: AbortSignal
+}

src/util/executable.ts

@@ -1,5 +1,6 @@
-import { QueryNode } from '../operation-node/query-node'
-import { NoResultErrorConstructor } from '../query-builder/no-result-error'
+import { QueryNode } from '../operation-node/query-node.js'
+import { NoResultErrorConstructor } from '../query-builder/no-result-error.js'
+import { ExecuteQueryOptions } from '../query-executor/query-executor.js'
 
 export interface Executable<O> {
   /**
@@ -34,15 +35,4 @@ export interface Executable<O> {
   ): Promise<O>
 }
 
-export interface ExecuteOptions {
-  /**
-   * An optional signal that can be used to abort the execution of the query.
-   *
-   * This is useful for cancelling long-running queries, for example when
-   * the user navigates away from the page or closes the browser tab.
-   *
-   * Writes (insert, update, delete) are not cancellable in most database engines,
-   * so this signal is mostly useful for read queries.
-   */
-  abortSignal?: AbortSignal
-}
+export interface ExecuteOptions extends ExecuteQueryOptions {}