Add async worker capabilities (#29)

Author: gitbuda

.eslintignore

@@ -1,3 +1 @@
-.git/
-build/
-node_modules/
+example/typescript/*.js

.github/workflows/ci.yml

@@ -24,12 +24,12 @@ jobs:
       uses: actions/cache@v1
       with:
         path: ~/memgraph
-        key: cache-memgraph-v1.6.1-docker-image
+        key: cache-memgraph-v2.0.1-docker-image
     - name: Download Memgraph Docker image
       if: steps.cache-memgraph-docker.outputs.cache-hit != 'true'
       run: |
         mkdir ~/memgraph
-        curl -L https://memgraph.com/download/memgraph/v1.6.1/docker/memgraph-1.6.1-community-docker.tar.gz > ~/memgraph/memgraph-docker.tar.gz
+        curl -L https://memgraph.com/download/memgraph/v2.0.1/docker/memgraph-2.0.1-docker.tar.gz > ~/memgraph/memgraph-docker.tar.gz
     - name: Load Memgraph Docker image
       run: |
         docker load -i ~/memgraph/memgraph-docker.tar.gz

.npmignore

@@ -0,0 +1,5 @@
+node_modules
+build/*
+!build/Release/nodemgclient.node
+.cache
+.github

CMakeLists.txt

@@ -43,9 +43,10 @@ endif()
 ExternalProject_Add(mgclient-proj
                     PREFIX         mgclient
                     GIT_REPOSITORY https://github.com/memgraph/mgclient.git
-                    GIT_TAG        63ffb016f2338e56ba7c5171d5f4938b6cec50f6
+                    GIT_TAG        v1.3.0
                     CMAKE_ARGS     "-DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>"
                                    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
+                                   "-DBUILD_CPP_BINDINGS=ON"
                     INSTALL_DIR    "${PROJECT_BINARY_DIR}/mgclient")
 ExternalProject_Get_Property(mgclient-proj install_dir)
 set(MGCLIENT_ROOT ${install_dir})
@@ -68,18 +69,21 @@ message(STATUS "MGCLIENT_LIBRARY: ${MGCLIENT_LIBRARY}")
 
 # Define the addon.
 include_directories(${CMAKE_JS_INC})
-set(SOURCE_FILES src/addon.cpp src/connection.cpp src/glue.cpp
-                 src/record.cpp src/cursor.cpp)
+set(SOURCE_FILES src/addon.cpp
+                 src/client.cpp
+                 src/glue.cpp)
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${CMAKE_JS_SRC})
 add_dependencies(${PROJECT_NAME} ${MGCLIENT_LIBRARY})
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 target_link_libraries(${PROJECT_NAME} PRIVATE
                       ${CMAKE_JS_LIB} ${MGCLIENT_LIBRARY}
                       project_warnings project_options)
-# TODO(gitbuda): hpp wrappers don't work yet because of exceptions.
-# Exceptions are disabled in this project. Decide and adjust.
 target_include_directories(${PROJECT_NAME} PRIVATE ${MGCLIENT_INCLUDE_DIRS})
-target_compile_options(${PROJECT_NAME} PRIVATE "-fno-exceptions")
+target_compile_options(${PROJECT_NAME} PRIVATE "")
+# C++ mgclient throws, which means this project has to enable exceptions. If at
+# any time we decide to disable exceptions with the combination of NAPI_THROW +
+# std::nullopt in case of an error, the code should work as is.
+add_definitions(-DNAPI_CPP_EXCEPTIONS)
 
 # Include N-API wrappers.
 execute_process(COMMAND node -p "require('node-addon-api').include"
@@ -88,10 +92,3 @@ execute_process(COMMAND node -p "require('node-addon-api').include"
 string(REPLACE "\n" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
 string(REPLACE "\"" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
 target_include_directories(${PROJECT_NAME} SYSTEM PRIVATE "${NODE_ADDON_API_DIR}")
-
-# Added because of BigInt support.
-add_definitions(-DNAPI_EXPERIMENTAL)
-# Cpp exceptions are disabled because the addon has to work with C primitives.
-# Any throw increases a chance for a memory leak because there is no room for
-# proper cleanup.
-add_definitions(-DNAPI_DISABLE_CPP_EXCEPTIONS)

README.md

@@ -8,18 +8,14 @@
 
 ## Installation
 
-`nodemgclient` is a wrapper around the
-[mgclient](https://github.com/memgraph/mgclient).
+### Build from Source on Linux
 
-### Build from Source
-
- To install `nodemgclient` from sources you will need (only Linux is tested at
- the moment):
+To install `nodemgclient` from sources you will need (only Linux is tested at
+the moment):
 
 * OpenSSL >= 1.0.2
 * A CMake >= 3.10
-* A Clang compiler supporting C11 standard
-* A Clang compiler supporting C++17 standard
+* A Clang compiler supporting C11 and C++17 standard
 * Node.js >= 12
 
 First install the prerequisites:
@@ -30,7 +26,7 @@ First install the prerequisites:
 sudo apt install -y npm nodejs cmake make gcc g++ clang libssl-dev
 ```
 
-* On CentOS:
+* On RedHat/CentOS:
 
 ```bash
 sudo yum install -y npm nodejs cmake3 make gcc gcc-c++ clang openssl-devel
@@ -43,12 +39,40 @@ npm ci
 npm run build:release
 ```
 
-To run tests, [Docker](https://docs.docker.com/engine/install) is required.
+To test ([Docker](https://docs.docker.com/engine/install) is required) run:
 
-## Windows
+```bash
+npm run test
+```
+### Build from Source on Windows
 
 NOTE: Not yet possible under MinGW.
 
 If installing OpenSSL package from
 https://slproweb.com/products/Win32OpenSSL.html, make sure to use the full one
-because of the header files.
+because of the header files.
+
+## Implementation and Interface Notes
+
+### Temporal Types
+
+Suitable JS type to store Memgrpah temporal types don't exist. In particular,
+it's impossible to convert `mg_duration` and `mg_local_time` to the `Date`
+type. Since [the temporal
+specification](https://github.com/tc39/proposal-temporal) is not yet widely
+supported, the decision was to expose plain JS objects (dict) with the exact
+fields `mgclient` is providing (for more details, please take a look under
+`mgclient`
+[header](https://github.com/memgraph/mgclient/blob/master/include/mgclient.h)
+and [source](https://github.com/memgraph/mgclient/blob/master/src/mgclient.c)
+files). In addition, when possible (`mg_date` and `mg_local_date_time`), are
+converted into objects which have `date` property,
+which in fact, is the JS `Date` representation of these types. Keep in mind the
+loss of precision because JS `Date` time fields can only store up to
+milliseconds precision. However, Memgraph supports microsecond precision for
+the local time and therefore any use of the `date` property (JS `Date` object)
+can potentially cause loss of information.
+
+Module exposes `create` functions, e.g. `createMgDate`, which simplify creation
+of temporal object interpretable by Memgraph. For more details take a look
+under the API docs under [index.js](./index.js) file.

cmake/CompilerWarnings.cmake

@@ -16,8 +16,9 @@ function(set_project_warnings project_name)
       -Woverloaded-virtual # warn if you overload (not override) a virtual
                            # function
       -Wpedantic # warn if non-standard C++ is used
-      -Wconversion # warn on type conversions that may lose data
-      -Wsign-conversion # warn on sign conversions
+      # TODO(gitbuda): Fix mgclient cpp issue and put back the conversion warnings.
+      # -Wconversion # warn on type conversions that may lose data
+      # -Wsign-conversion # warn on sign conversions
       -Wnull-dereference # warn if a null dereference is detected
       -Wdouble-promotion # warn if float is implicit promoted to double
       -Wformat=2 # warn on security issues around functions that format output

example/async_connection.js

@@ -0,0 +1,70 @@
+// Copyright (c) 2016-2021 Memgraph Ltd. [https://memgraph.com]
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// TODO(gitbuda): Make tests out of this async example.
+
+const memgraph = require('..');
+
+(async () => {
+  try {
+    const client = memgraph.Client();
+    client
+      .Connect({ host: 'localhost' })
+      .then(async (connection) => {
+        console.log('Connected!');
+        connection
+          .Execute('MATCH (n) WHERE n.name = $name RETURN n, n.name;', {
+            name: 'TEST',
+          })
+          .then(async (_) => {
+            try {
+              try {
+                await connection.Execute('MATCH (n) RETURN n;');
+              } catch (e) {
+                console.log('The second MATCH should fail: ' + e);
+              }
+              let data = await connection.FetchAll();
+              console.log(data);
+              data = await connection.FetchOne();
+              console.log(data);
+              data = await connection.FetchOne();
+              console.log(data);
+            } catch (e) {
+              console.log(e);
+            }
+          })
+          .catch((e) => {
+            console.log(e);
+          });
+      })
+      .catch((e) => {
+        console.log(e);
+      });
+    console.log('Connecting...');
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    const txConn = await memgraph
+      .Client()
+      .Connect({ host: 'localhost', port: 7687 });
+    await txConn.Begin();
+    await txConn.Execute('CREATE (), ();');
+    await txConn.FetchAll();
+    await txConn.Execute('CREATE (), ();');
+    const txConnData = await txConn.FetchAll();
+    console.log(txConnData);
+    await txConn.Commit();
+  } catch (e) {
+    console.log(e);
+  }
+})();

example/count_nodes_edges.js

@@ -12,19 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-const memgraph = require('../lib');
+const memgraph = require('..');
 const query = require('../test/queries');
 
-const connection = memgraph.Connect({ host: 'localhost', port: 7687 });
-
 (async () => {
   try {
-    await connection.ExecuteAndFetchRecords(query.DELETE_ALL);
-    await connection.ExecuteAndFetchRecords(query.CREATE_RICH_NODE);
-    await connection.ExecuteAndFetchRecords(query.CREATE_RICH_EDGE);
+    const connection = await memgraph.Connect({
+      host: 'localhost',
+      port: 7687,
+    });
+    await connection.ExecuteAndFetchAll(query.DELETE_ALL);
+    await connection.ExecuteAndFetchAll(query.CREATE_RICH_NODE);
+    await connection.ExecuteAndFetchAll(query.CREATE_RICH_EDGE);
 
-    console.log(await connection.ExecuteAndFetchRecords(query.NODES));
-    console.log(await connection.ExecuteAndFetchRecords(query.EDGES));
+    console.log(await connection.ExecuteAndFetchAll(query.NODES));
+    console.log(await connection.ExecuteAndFetchAll(query.EDGES));
   } catch (e) {
     console.log(e);
   }

example/create_node_edge.js

@@ -12,16 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-const memgraph = require('../lib');
+const memgraph = require('..');
 const query = require('../test/queries');
 
-const connection = memgraph.Connect({ host: 'localhost', port: 7687 });
-
 (async () => {
   try {
-    await connection.ExecuteAndFetchRecords(query.DELETE_ALL);
-    await connection.ExecuteAndFetchRecords(query.CREATE_PATH);
-    const paths = await connection.ExecuteAndFetchRecords(query.MATCH_PATHS);
+    const connection = await memgraph.Connect({
+      host: 'localhost',
+      port: 7687,
+    });
+    await connection.ExecuteAndFetchAll(query.DELETE_ALL);
+    await connection.ExecuteAndFetchAll(query.CREATE_PATH);
+    const paths = await connection.ExecuteAndFetchAll(query.MATCH_PATHS);
     console.log(paths);
   } catch (e) {
     console.log(e);