Bind timeout function for Node.js APIs

tools/nodejs_api/src_cpp/include/node_connection.h

@@ -25,6 +25,7 @@ class NodeConnection : public Napi::ObjectWrap<NodeConnection> {
     Napi::Value InitAsync(const Napi::CallbackInfo& info);
     void InitCppConnection();
     void SetMaxNumThreadForExec(const Napi::CallbackInfo& info);
+    void SetQueryTimeout(const Napi::CallbackInfo& info);
     Napi::Value ExecuteAsync(const Napi::CallbackInfo& info);
 
 private:

tools/nodejs_api/src_cpp/node_connection.cpp

@@ -15,6 +15,7 @@ Napi::Object NodeConnection::Init(Napi::Env env, Napi::Object exports) {
             InstanceMethod("initAsync", &NodeConnection::InitAsync),
             InstanceMethod("executeAsync", &NodeConnection::ExecuteAsync),
             InstanceMethod("setMaxNumThreadForExec", &NodeConnection::SetMaxNumThreadForExec),
+            InstanceMethod("setQueryTimeout", &NodeConnection::SetQueryTimeout),
         });
 
     exports.Set("NodeConnection", t);
@@ -44,6 +45,28 @@ void NodeConnection::InitCppConnection() {
     database.reset();
 }
 
+void NodeConnection::SetMaxNumThreadForExec(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    size_t numThreads = info[0].ToNumber().Int64Value();
+    try {
+        this->connection->setMaxNumThreadForExec(numThreads);
+    } catch (const std::exception& exc) {
+        Napi::Error::New(env, std::string(exc.what())).ThrowAsJavaScriptException();
+    }
+}
+
+void NodeConnection::SetQueryTimeout(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    size_t timeout = info[0].ToNumber().Int64Value();
+    try {
+        this->connection->setQueryTimeOut(timeout);
+    } catch (const std::exception& exc) {
+        Napi::Error::New(env, std::string(exc.what())).ThrowAsJavaScriptException();
+    }
+}
+
 Napi::Value NodeConnection::ExecuteAsync(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     Napi::HandleScope scope(env);
@@ -62,15 +85,3 @@ Napi::Value NodeConnection::ExecuteAsync(const Napi::CallbackInfo& info) {
     }
     return info.Env().Undefined();
 }
-
-void NodeConnection::SetMaxNumThreadForExec(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    size_t numThreads = info[0].ToNumber().Int64Value();
-    try {
-        this->connection->setMaxNumThreadForExec(numThreads);
-    } catch (const std::exception& exc) {
-        Napi::Error::New(env, std::string(exc.what())).ThrowAsJavaScriptException();
-    }
-}
-

tools/nodejs_api/src_js/connection.js

@@ -56,6 +56,9 @@ class Connection {
               if (this._numThreads) {
                 this._connection.setMaxNumThreadForExec(this._numThreads);
               }
+              if (this._queryTimeout) {
+                this._connection.setQueryTimeout(this._queryTimeout);
+              }
               resolve();
             }
           });
@@ -194,10 +197,31 @@ class Connection {
     if (typeof numThreads !== "number" || !numThreads || numThreads < 0) {
       throw new Error("numThreads must be a positive number.");
     }
-    if (!this.isInitialized) {
+    if (this._isInitialized) {
       this._connection.setMaxNumThreadForExec(numThreads);
+    } else {
+      this._numThreads = numThreads;
+    }
+  }
+
+  /**
+   * Set the timeout for queries. Queries that take longer than the timeout
+   * will be aborted.
+   * @param {Number} timeoutInMs the timeout in milliseconds.
+   */
+  setQueryTimeout(timeoutInMs) {
+    if (
+      typeof timeoutInMs !== "number" ||
+      isNaN(timeoutInMs) ||
+      timeoutInMs <= 0
+    ) {
+      throw new Error("timeoutInMs must be a positive number.");
+    }
+    if (this._isInitialized) {
+      this._connection.setQueryTimeout(timeoutInMs);
+    } else {
+      this._queryTimeout = timeoutInMs;
     }
-    this._numThreads = numThreads;
   }
 }
 

tools/nodejs_api/test/test_connection.js

@@ -89,10 +89,7 @@ describe("Execute", function () {
       await conn.execute(preparedStatement, { 1: 0 });
       assert.fail("No error thrown when the prepared statement is invalid.");
     } catch (e) {
-      assert.equal(
-        e.message,
-        "Binder exception: Table dog does not exist."
-      );
+      assert.equal(e.message, "Binder exception: Table dog does not exist.");
     }
   });
 
@@ -185,10 +182,7 @@ describe("Query", function () {
       await conn.query("MATCH (a:dog) RETURN COUNT(*)");
       assert.fail("No error thrown when the query is invalid.");
     } catch (e) {
-      assert.equal(
-        e.message,
-        "Binder exception: Table dog does not exist."
-      );
+      assert.equal(e.message, "Binder exception: Table dog does not exist.");
     }
   });
 
@@ -201,3 +195,33 @@ describe("Query", function () {
     }
   });
 });
+
+describe("Timeout", function () {
+  it("should abort a query if the timeout is reached", async function () {
+    try {
+      const newConn = new kuzu.Connection(db);
+      await newConn.init();
+      newConn.setQueryTimeout(1);
+      await newConn.query(
+        "MATCH (a:person)-[:knows*1..28]->(b:person) RETURN COUNT(*);"
+      );
+      assert.fail("No error thrown when the query times out.");
+    } catch (err) {
+      assert.equal(err.message, "Interrupted.");
+    }
+  });
+
+  it("should allow setting a timeout before the connection is initialized", async function () {
+    try {
+      const newConn = new kuzu.Connection(db);
+      newConn.setQueryTimeout(1);
+      await newConn.init();
+      await newConn.query(
+        "MATCH (a:person)-[:knows*1..28]->(b:person) RETURN COUNT(*);"
+      );
+      assert.fail("No error thrown when the query times out.");
+    } catch (err) {
+      assert.equal(err.message, "Interrupted.");
+    }
+  });
+});