@openziti/ziti-sdk-nodejs 0.24.1 → 0.25.0

package/CMakeLists.txt

@@ -35,6 +35,10 @@ target_include_directories(${PROJECT_NAME}
         PRIVATE ${CMAKE_JS_INC}
 )
 
+target_compile_definitions(${PROJECT_NAME}
+        PRIVATE ZITI_LOG_MODULE="ziti-njs"
+)
+
 if (WIN32)
   target_compile_definitions(${PROJECT_NAME} PRIVATE WIN32_LEAN_AND_MEAN)
 endif (WIN32)

package/lib/init.js

@@ -19,17 +19,24 @@ limitations under the License.
 
   return new Promise((resolve, reject) => {
 
-      let rc = ziti.ziti_init( identityPath, ( result ) => {
+      try {
+          ziti.ziti_init( identityPath, ( result ) => {
 
-          return resolve( result );
-        
-      });
+              if (result instanceof Error) {
+                  return reject(result);
+              }
 
-      if (rc < 0) {
-        return reject(`ziti.init() failed with return code ${rc}`);
+              return resolve( result );
+          });
+      } catch (e) {
+          reject(e);
       }
-      
   });
 };
 
+const shutdown = () => {
+    ziti.ziti_shutdown();
+}
+
 exports.init = init;
+exports.shutdown = shutdown;

package/lib/{setLogLevel.js → logger.js}

@@ -26,4 +26,12 @@ const setLogLevel = ( lvl ) => {
 
 };
 
+const setLogger = ( loggerFunc ) => {
+
+  ziti.ziti_set_logger( loggerFunc );
+
+}
+
 exports.setLogLevel = setLogLevel;
+exports.setLogger = setLogger;
+

package/lib/ziti.js

@@ -21,27 +21,17 @@ limitations under the License.
  * 
  */
 
-var binding;
-
-function importAll (r) {
-  r.keys().forEach(key => {
-    binding = r(key); // Load the addon
-  });
+const logger = require('./logger');
+
+function load_addon() {
+    try {
+        return require('../build/Debug/ziti_sdk_nodejs');
+    } catch {
+        return require('../build/Release/ziti_sdk_nodejs');
+    }
 }
 
-if (typeof require.context == 'function') {
-
-  importAll( require.context("../build/", true, /\.node$/) );
-
-} else {
-
-    const binary = require('@mapbox/node-pre-gyp');
-    const path = require('path')
-    const binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')), {debug: false});
-
-    binding = require(binding_path);
-    
-}
+const binding = load_addon();
 
 ziti = module.exports = exports = binding;
 
@@ -188,7 +178,20 @@ exports.listen            = require('./listen').listen;
  * @param {number} level - 0=NONE, 1=ERROR, 2=WARN, 3=INFO, 4=DEBUG, 5=TRACE
  * @returns {void} No return value.
  */
-exports.setLogLevel       = require('./setLogLevel').setLogLevel;
+exports.setLogLevel       = logger.setLogLevel;
+
+/**
+ * Set the logger function.
+ *
+ * **Note**: passing log messages to your own logger
+ * function will likely have a negative impact on performance. Use with caution.
+ *
+ * @function setLogger
+ * @param {function} loggerFunc - A function that accepts a log message object
+ * with the following properties: { level, source, message }
+ * @returns {undefined} No return value.
+ */
+exports.setLogger         = logger.setLogger;
 
 /**
  * Set the logging level.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openziti/ziti-sdk-nodejs",
   "description": "A NodeJS-based SDK for delivering secure applications over a Ziti Network",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "main": "./lib/ziti",
   "scripts": {
     "build": "npm run build:configure && npm run build:make",
@@ -11,9 +11,8 @@
     "build:make": "cmake-js build",
     "build:package": "node-pre-gyp package",
     "clean": "cmake-js clean",
-    "test": "node tests/hello.js",
+    "test": "node --test --test-timeout=20000 tests/*.test.*js",
     "install": "node-pre-gyp install || npm run build",
-    "publish": "node-pre-gyp package publish",
     "docs": "jsdoc2md -t API_REFERENCE.hbs lib/*.js > API_REFERENCE.md"
   },
   "repository": {
@@ -23,9 +22,9 @@
   "binary": {
     "module_name": "ziti_sdk_nodejs",
     "module_path": "./build/{configuration}/",
-    "remote_path": "./{module_name}/v{version}/{configuration}/",
+    "remote_path": "./openziti/ziti-sdk-nodejs/releases/download/{version}/",
     "package_name": "{module_name}-v{version}-{node_abi}-{platform}-{arch}.tar.gz",
-    "host": "https://ziti-npm.s3.amazonaws.com"
+    "host": "https://github.com"
   },
   "license": "Apache-2.0",
   "licenses": [
@@ -39,14 +38,13 @@
     "nodejs"
   ],
   "engines": {
-    "node": ">=11.0.0"
+    "node": ">=20.0.0"
   },
   "author": {
     "name": "OpenZiti",
     "url": "http://openziti.io"
   },
   "devDependencies": {
-    "aws-sdk": "^2.1692.0",
     "cmake-js": "^8.0.0",
     "docdash": "^1.2.0",
     "jsdoc": "^4.0.4",

package/tests/addon.test.js

@@ -0,0 +1,23 @@
+const ziti = require("../ziti.js");
+const assert = require("node:assert");
+const test = require("node:test");
+const suite = test.suite;
+
+suite("Ziti SDK Addon Tests", () => {
+    test("ziti.exports tests", () => {
+        assert(typeof ziti.ziti_sdk_version === "function", "ziti_sdk_version should be a function");
+        assert(typeof ziti.enroll === "function", "ziti_enroll should be a function");
+        assert(typeof ziti.setLogger === "function", "ziti_set_logger should be a function");
+
+    })
+    test("ziti_sdk_version test", () => {
+        const result = ziti.ziti_sdk_version();
+        console.log("ziti_sdk_version() result is: ", result);
+        assert(result !== "", "ziti_sdk_version should not return an empty string");
+    })
+})
+
+
+
+
+

package/tests/context.test.mjs

@@ -0,0 +1,91 @@
+import ziti from "../ziti.js";
+import assert from "node:assert";
+import test from "node:test";
+const suite = test.suite;
+
+ziti.setLogLevel(5)
+
+suite("Ziti SDK Context Tests", { timeout: 30000 }, () => {
+    test.afterEach(() => {
+        ziti.ziti_shutdown()
+    })
+
+    test("ziti.shutdown not fail", () => {
+        ziti.ziti_shutdown()
+    })
+
+    test("ziti.ziti_init with bad args", (done) => {
+        assert.throws(() => {
+            ziti.ziti_init()
+        }, {
+            message: "Too few arguments",
+            code: "EINVAL"
+        })
+        assert.throws(() => {
+            ziti.ziti_init("valid-config")
+        }, {
+            message: "Too few arguments",
+            code: "EINVAL"
+        })
+    })
+
+    test("ziti.ziti_init with invalid config", (done) => {
+        assert.throws(() => {
+                ziti.ziti_init("not-a-valid-config", () => {
+                    assert.fail("should not called")
+                })
+            },
+            {
+                message: "configuration not found",
+                code: 'EINVAL'
+            }
+        )
+        ziti.init("not-a-valid-config").then(
+            () => {
+                assert.fail("should not resolve")
+            },
+            (err) => {
+                assert.strictEqual(err.message, 'configuration not found')
+                assert.strictEqual(err.code, 'EINVAL')
+            }
+        )
+        assert.rejects(() => ziti.init("not-a-valid-config"),
+            {
+                code: 'EINVAL',
+                message: 'configuration not found'
+            })
+    })
+
+    test("incomplete config", () => {
+        const cfg = {
+            id: {
+                cert: 'cert',
+                key: 'key',
+                ca: 'ca'
+            }
+        }
+
+        const cfgStr = JSON.stringify(cfg)
+        assert.throws(() => {
+            ziti.ziti_init(cfgStr, (err) => {
+                assert.fail("should not called")
+            })
+        })
+        assert.rejects(() => ziti.init(cfgStr), { message: 'configuration is invalid'})
+    })
+
+    test("complete but invalid config", async () => {
+        const cfg = {
+            ztAPI: "http://localhost:6262",
+            id: {
+                cert: 'cert',
+                key: 'key',
+                ca: 'ca'
+            }
+        }
+
+        const cfgStr = JSON.stringify(cfg)
+        await assert.rejects(() => ziti.init(cfgStr), { message: 'configuration is invalid'})
+    })
+
+})

package/tests/logger.test.mjs

@@ -0,0 +1,24 @@
+import ziti from "../ziti.js";
+import test from "node:test";
+import assert from "node:assert";
+import { setTimeout as delay } from 'node:timers/promises';
+
+test('setLogger test', async () => {
+    const messages = [];
+    ziti.setLogger(
+        (msg) => {
+            messages.push(msg);
+        }
+    );
+
+    ziti.setLogLevel(5);
+    await delay(1000);
+    assert(messages.length > 0, "Logger callback should have been called at least once");
+    assert(messages.some(msg => msg.message.includes("set log level")),
+        "Logger should contain log level set message"
+    );
+})
+
+
+
+

package/tests/hello.js

@@ -1,18 +0,0 @@
-
-const bindings = require('bindings')('ziti_sdk_nodejs')
-
-console.log(bindings)
-const result = bindings.ziti_sdk_version();
-console.log("ziti_sdk_version() result is: ", result);
-
-
-
-const binary = require('@mapbox/node-pre-gyp');
-const path = require('path')
-// const binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')), {debug: true});
-const binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')));
-console.log("binding_path is: ", binding_path);
-const ziti = require(binding_path);
-console.log("ziti native addon is: \n", ziti);
-require('assert').notEqual(result,"");
-console.log("SUCCESS");