How to use functions, written on c++, in node.js

Question

I have a basic c++ file. I have a node server. One of the functions there gets a number, makes calculation and returns another number. And I want to make this function work faster rewriting it on c++. So I want to be able to call the function written on c++ in a .cpp file from .js file. When I write node index.js all .cpp files should be compiled, then functions from them should be "require();" in .js files and then I want to be able to use them in .js file calling as common functions: e.g. calc(number, param);. How do I do it? I tried to read some articles about that and watched some videos on YouTube and made something, but when it starts I get a lor of errors like

gyp ERR! find Python Python is not set from command line or npm configuration
gyp ERR! find Python Python is not set from environment variable PYTHON
gyp ERR! find Python checking if "python" can be used
gyp ERR! find Python - "python" is not in PATH or produced an error

As I understand, it wants me to install python on my computer. But what for? I do not need python, I want to compile and execute c++ from node.js.

My implementation: index.js

var testlib = require('./build/Release/testlib');

testlib.addThousandToNumber(20, function(err, res)
{
    if (err)
        console.error(err);
    else
        console.log(res);
});

package.json

  "name": "testlib",
  "version": "1.0.0",
  "description": "",
  "main": "run.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "install": "node-gyp clean configure build"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "nan": "^2.14.1",
    "node-gyp": "^7.0.0"
  }
}

binding.gyp

    "targets": [{
        "target_name": "testlib",
        "sources": ["testlib.cpp", "testworker.cpp"],
        "include_dirs": ["<!(node -e \"require('nan')\""]
    }]
}

testlib.cpp

#include <nan.h>
#include "testworker.h"

NAN_METHOD(addThoudsandToNumber)
{
    auto number = Nan::To<int>(info[0]).FromJust();
    auto *callback = new Nan::Callback(info[1].As<v8::Function());
    Nan::AsyncQueueWorker(new TestWorker(number, callback));
}
NAN_MODULE_INIT(init)
{
    Nan::SetMethod(target, "addThousandTonumber", addThousandToNumber);
}

NODU_MODULE(testlib, init);

testworker.cpp

#include "testworker.h"

void TestWorker::Execute()
{
    for (int i = 0; i < 1000; i++)
    {
        myNumber++;
    }
}

void TestWorker::HandleOKCallback()
{
    Nan::HandleScope scope;
    auto NumberJS = Nan::New(myNumber);
    v8::Local<v8::Value> argv[] = {Nan::Undefined(), numberJS};
    myCallback->Call(2, argv);
}

testworker.h

#include <nan.h>

class TestWorker : public Nan::AsyncWorker
{
    public:
        TestWorker(int number, Nan::Callback * callback) :
            Nan::AsyncWorker(callback), myNumber(number), myCallback(callback) { }
    
        ~TestWorker() { delete callback }

        void Execute();
        void HandleOKCallback();
    private:
        int myNumber;
        Nan::Callback * myCallback;
}

Answer 1

May be this is what you are looking for: cmake-js

"CMake.js is a Node.js/io.js native addon build tool which works (almost) exactly like node-gyp, but instead of gyp, it is based on CMake build system"

Answer 2

If your primary goal is just to make some high-performance calculations in C++ with the web interface, you might be interested in compiling and linking your function directly into a HTTP engine, like in Node++:

https://github.com/rekmus/nodepp

void npp_app_main()
{
    if ( REQ("") )   // landing
    {
        // ...
    }
    else if ( REQ("calc") )  // calculate
    {
        int number;
        // get number from the query string:
        if ( QSI("number", &number) )
        {
            int result = calc(number, param);
            // return result to the client:
            OUT("{\"result\":%d}", result);
            RES_CONTENT_TYPE_JSON;
        }
    }
    else
    {
        RES_STATUS(404);
    }
}

Besides the calc time, the engine latency is around 5-20 µs on an average PC (Linux). The added benefit is that Node++ is fairly independent (requires only OS, GCC and OpenSSL if you want HTTPS).