Cleanup execute endpoints

Author: adespawn

lib/client.js

@@ -319,56 +319,50 @@ class Client extends events.EventEmitter {
             await this.#connect();
         }
 
-        return new Promise((resolve, reject) => {
-            this.#executePromise(resolve, reject, query, params, execOptions);
-        });
-    }
+        let rustOptions = execOptions.getRustOptions();
+        let result;
 
-    /**
-     * Core part of executing rust queries
-     * @param {ResolveCallback} resolve
-     * @param {RejectCallback} reject
-     * @param {string | rust.PreparedStatementWrapper} query
-     * @param {Array} params
-     * @param {ExecOptions.ExecutionOptions} execOptions
-     */
-    async #executePromise(resolve, reject, query, params, execOptions) {
-        try {
-            let rustOptions = execOptions.getRustOptions();
-            let result;
-            if (execOptions.isPrepared()) {
-                // Execute prepared statement, as requested by the user
-                let statement =
-                    query instanceof rust.PreparedStatementWrapper
-                        ? query
-                        : await this.rustClient.prepareStatement(query);
-                let parsedParams = parseParams(
-                    statement.getExpectedTypes(),
-                    params,
-                );
-                result = await this.rustClient.executePreparedUnpaged(
-                    statement,
-                    parsedParams,
-                    rustOptions,
-                );
-            } else {
-                if (query instanceof rust.PreparedStatementWrapper) {
-                    throw new Error(
-                        "Unexpected prepared statement wrapper for unprepared queries",
-                    );
-                }
-                let expectedTypes = convertHints(execOptions.getHints() || []);
-                let parsedParams = parseParams(expectedTypes, params, true);
-                result = await this.rustClient.queryUnpaged(
-                    query,
-                    parsedParams,
-                    rustOptions,
+        if (execOptions.isPrepared()) {
+            // If the statement is already prepared, skip the preparation process
+            // Otherwise call Rust part to prepare a statement
+            let statement =
+                query instanceof rust.PreparedStatementWrapper
+                    ? query
+                    : await this.rustClient.prepareStatement(query);
+
+            // Parse parameters according to expected types
+            let parsedParams = parseParams(
+                statement.getExpectedTypes(),
+                params,
+                false,
+            );
+
+            // Execute query
+            result = await this.rustClient.executePreparedUnpaged(
+                statement,
+                parsedParams,
+                rustOptions,
+            );
+        } else {
+            // We do not accept already prepared statements for unprepared queries
+            if (query instanceof rust.PreparedStatementWrapper) {
+                throw new Error(
+                    "Unexpected prepared statement wrapper for unprepared queries",
                 );
             }
-            resolve(new ResultSet(result));
-        } catch (e) {
-            reject(e);
+            // Get expected types from user provided hints
+            let expectedTypes = convertHints(execOptions.getHints() || []);
+            // Parse parameters according to provided hints, with type guessing
+            let parsedParams = parseParams(expectedTypes, params, true);
+
+            // Execute query
+            result = await this.rustClient.queryUnpaged(
+                query,
+                parsedParams,
+                rustOptions,
+            );
         }
+        return new ResultSet(result);
     }
 
     /**
@@ -523,28 +517,47 @@ class Client extends events.EventEmitter {
         const rustOptions = queryOptions.queryOptionsIntoWrapper(execOptions);
         let result;
         if (execOptions.isPrepared()) {
-            // Execute prepared statement, as requested by the user
-            const statement = await this.rustClient.prepareStatement(query);
+            // If the statement is already prepared, skip the preparation process
+            // Otherwise call Rust part to prepare a statement
+            let statement =
+                query instanceof rust.PreparedStatementWrapper
+                    ? query
+                    : await this.rustClient.prepareStatement(query);
+
+            // Parse parameters according to expected types
             let parsedParams = parseParams(
                 statement.getExpectedTypes(),
                 params,
             );
+
+            // Execute query
             result = await this.rustClient.executeSinglePage(
                 statement,
                 parsedParams,
                 rustOptions,
                 pageState,
             );
         } else {
+            // We do not accept already prepared statements for unprepared queries
+            if (query instanceof rust.PreparedStatementWrapper) {
+                throw new Error(
+                    "Unexpected prepared statement wrapper for unprepared queries",
+                );
+            }
+            // Get expected types from user provided hints
             const expectedTypes = convertHints(execOptions.getHints() || []);
+            // Parse parameters according to provided hints, with type guessing
             const parsedParams = parseParams(expectedTypes, params, true);
+            // Execute query
             result = await this.rustClient.querySinglePage(
                 query,
                 parsedParams,
                 rustOptions,
                 pageState,
             );
         }
+        // result[0] - information about page state
+        // result[1] - object representing result itself
         result[1] = new ResultSet(result[1], result[0]);
         return result;
     }