@port-labs/jq-node-bindings 0.0.15-dev2 → 1.0.0

package/lib/jq.js

@@ -15,7 +15,6 @@ class JqExecCompileError extends JqExecError {
 }
 
 const exec = (object, filter, {enableEnv = false, throwOnError = false} = {}) => {
-  console.log("exec",object,filter)
   try {
     const data = nativeJq.execSync(JSON.stringify(object), formatFilter(filter, {enableEnv}))
 
@@ -29,7 +28,6 @@ const exec = (object, filter, {enableEnv = false, throwOnError = false} = {}) =>
 }
 
 const execAsync = async (object, filter, {enableEnv = false, throwOnError = false} = {}) => {
-  console.log(object,filter)
   try {
     const data = await nativeJq.execAsync(JSON.stringify(object), formatFilter(filter, {enableEnv}))
     return data?.value;

package/lib/templateAsync.js

@@ -119,7 +119,6 @@ const renderRecursivelyAsync = async(inputJson, template, execOptions = {}) => {
             `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(evaluatedKey)}`,
           );
         }
-        console.log("evaluatedKey",evaluatedKey,value)
         return evaluatedKey ? [[evaluatedKey, await renderRecursivelyAsync(inputJson, value, execOptions)]] : [];
       });
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@port-labs/jq-node-bindings",
-  "version": "v0.0.15-dev2",
+  "version": "v1.0.0",
   "description": "Node.js bindings for JQ",
-  "jq-node-bindings": "0.0.15-dev2",
+  "jq-node-bindings": "1.0.0",
   "main": "lib/index.js",
   "scripts": {
     "configure": "node-gyp configure",

package/src/binding.cc

@@ -9,23 +9,40 @@
 #include "src/binding.h"
 
 
-#ifdef DEBUG_MODE
-static bool debug_enabled = true;
-#else
-static bool debug_enabled = false;
-#endif
+// #ifdef DEBUG_MODE
+// static bool debug_enabled = true;
+// #else
+// static bool debug_enabled = false;
+// #endif
+
+// #define DEBUG_LOG(fmt, ...) \
+//     do { if (debug_enabled) printf("[DEBUG] " fmt "\n", ##__VA_ARGS__); } while (0)
 
-#define DEBUG_LOG(fmt, ...) \
-    do { if (debug_enabled) printf("[DEBUG] " fmt "\n", ##__VA_ARGS__); } while (0)
+// #define ASYNC_DEBUG_LOG(work, fmt, ...) \
+//     do { if (debug_enabled) printf("[DEBUG][ASYNC][%p] " fmt "\n", (jv*)work, ##__VA_ARGS__); } while (0)
 
-#define ASYNC_DEBUG_LOG(work, fmt, ...) \
-    do { if (debug_enabled) printf("[DEBUG][ASYNC][%p] " fmt "\n", (jv*)work, ##__VA_ARGS__); } while (0)
+// #define CACHE_DEBUG_LOG(cache, fmt, ...) \
+//     do { if (debug_enabled) printf("[DEBUG][CACHE][%p] " fmt "\n", (void*)cache, ##__VA_ARGS__); } while (0)
 
-#define CACHE_DEBUG_LOG(cache, fmt, ...) \
-    do { if (debug_enabled) printf("[DEBUG][CACHE][%p] " fmt "\n", (void*)cache, ##__VA_ARGS__); } while (0)
+// #define WRAPPER_DEBUG_LOG(wrapper, fmt, ...) \
+//     do { if (debug_enabled) printf("[DEBUG][WRAPPER:%p] " fmt "\n", (void*)wrapper, ##__VA_ARGS__); } while (0)
+#ifdef ENABLE_DEBUG  // We'll use ENABLE_DEBUG as our flag name
+#define DEBUG_ENABLED 1
+#else
+#define DEBUG_ENABLED 0
+#endif
 
-#define WRAPPER_DEBUG_LOG(wrapper, fmt, ...) \
-    do { if (debug_enabled) printf("[DEBUG][WRAPPER:%p] " fmt "\n", (void*)wrapper, ##__VA_ARGS__); } while (0)
+#ifdef ENABLE_DEBUG
+#define DEBUG_LOG(fmt, ...) fprintf(stderr, "[DEBUG] " fmt "\n", ##__VA_ARGS__)
+#define ASYNC_DEBUG_LOG(work, fmt, ...) fprintf(stderr, "[DEBUG][ASYNC][%p] " fmt "\n", (void*)work, ##__VA_ARGS__)
+#define CACHE_DEBUG_LOG(cache, fmt, ...) fprintf(stderr, "[DEBUG][CACHE][%p] " fmt "\n", (void*)cache, ##__VA_ARGS__)
+#define WRAPPER_DEBUG_LOG(wrapper, fmt, ...) fprintf(stderr, "[DEBUG][WRAPPER][%p] " fmt "\n", (void*)wrapper, ##__VA_ARGS__)
+#else
+#define DEBUG_LOG(fmt, ...) ((void)0)
+#define ASYNC_DEBUG_LOG(work, fmt, ...) ((void)0)
+#define CACHE_DEBUG_LOG(cache, fmt, ...) ((void)0)
+#define WRAPPER_DEBUG_LOG(wrapper, fmt, ...) ((void)0)
+#endif
 
 static size_t global_cache_size = 100;
 
@@ -81,7 +98,6 @@ struct JqFilterWrapper {
 public:
     std::string filter_name;
     std::list<JqFilterWrapper*>::iterator cache_pos;
-
     /* init mutex and set filter_name */
     explicit JqFilterWrapper(jq_state* jq_, std::string filter_name_) : 
         filter_name(filter_name_), 
@@ -124,7 +140,7 @@ private:
     pthread_mutex_t cache_mutex; 
     std::list<JqFilterWrapper*> item_list;
     std::unordered_map<KEY_T,  JqFilterWrapper*> item_map;
-    std::unordered_map<JqFilterWrapper*,  bool> is_item_in_use;
+    std::unordered_map<JqFilterWrapper*,  size_t> item_refcnt;
 
     size_t cache_size;
 
@@ -139,8 +155,8 @@ private:
             auto last_it = item_list.end();
             last_it--;
             JqFilterWrapper* wrapper = *last_it;
-            CACHE_DEBUG_LOG((void*)wrapper, "Examining wrapper: name='%s', is_in_use=%zu", wrapper->filter_name.c_str(), is_item_in_use[wrapper]);
-            if(is_item_in_use[wrapper]){
+            CACHE_DEBUG_LOG((void*)wrapper, "Examining wrapper: name='%s', refcnt=%zu", wrapper->filter_name.c_str(), item_refcnt[wrapper]);
+            if(item_refcnt[wrapper]>0){
                 CACHE_DEBUG_LOG((void*)wrapper, "Wrapper is busy, skipping");
                 break;
             }
@@ -152,7 +168,7 @@ private:
                 CACHE_DEBUG_LOG((void*)wrapper, "Removing wrapper from cache");
                 item_map.erase(wrapper->filter_name);
             };
-            is_item_in_use.erase(wrapper);
+            item_refcnt.erase(wrapper);
             item_list.pop_back();
             CACHE_DEBUG_LOG((void*)wrapper, "Deleting wrapper");
             delete wrapper; 
@@ -171,20 +187,20 @@ public:
         //clear cache
         pthread_mutex_destroy(&cache_mutex);
     }
-    void set_item_in_use_true(JqFilterWrapper* val){
+    void inc_refcnt(JqFilterWrapper* val){
         CACHE_DEBUG_LOG((void*)val, "Incrementing refcnt for wrapper:%p", (void*)val);
-        is_item_in_use[val] = true;
+        item_refcnt[val]++;
     }
-    void set_item_in_use_false(JqFilterWrapper* val){
+    void dec_refcnt(JqFilterWrapper* val){
         pthread_mutex_lock(&cache_mutex);
         CACHE_DEBUG_LOG((void*)val, "Decrementing refcnt for wrapper:%p", (void*)val);
-        is_item_in_use[val] = false;
+        item_refcnt[val]--;
         pthread_mutex_unlock(&cache_mutex);
     }
     void put(const KEY_T &key, JqFilterWrapper* val) {
         CACHE_DEBUG_LOG((void*)val, "Putting key='%s' wrapper:%p", key.c_str(), (void*)val);
         pthread_mutex_lock(&cache_mutex);
-        set_item_in_use_true(val);
+        inc_refcnt(val);
         CACHE_DEBUG_LOG((void*)val, "Got cache lock for put operation");
 
         auto it = item_map.find(key);
@@ -217,9 +233,9 @@ public:
         item_list.erase(wrapper->cache_pos);
         item_list.push_front(wrapper);
         wrapper->cache_pos = item_list.begin();
-        set_item_in_use_true(wrapper);
-        CACHE_DEBUG_LOG((void*)wrapper, "Cache hit for jq wrapper,pointer=%p,name=%s", 
-                 (void*)wrapper, wrapper->filter_name.c_str());
+        inc_refcnt(wrapper);
+        CACHE_DEBUG_LOG((void*)wrapper, "Cache hit for jq wrapper,pointer=%p,name=%s,refcnt=%zu", 
+                 (void*)wrapper, wrapper->filter_name.c_str(),item_refcnt[wrapper]);
         pthread_mutex_unlock(&cache_mutex);
         CACHE_DEBUG_LOG((void*)wrapper, "Released cache lock after get");
         return wrapper;
@@ -412,13 +428,13 @@ napi_value ExecSync(napi_env env, napi_callback_info info) {
         napi_throw_error(env, nullptr, err_msg_conversion.c_str());
         jv_free(result);
         wrapper->unlock();
-        cache.set_item_in_use_false(wrapper);
+        cache.dec_refcnt(wrapper);
         return nullptr;
     }
 
     jv_free(result);
     wrapper->unlock();
-    cache.set_item_in_use_false(wrapper);
+    cache.dec_refcnt(wrapper);
     return ret;
 }
 
@@ -430,7 +446,8 @@ struct AsyncWork {
     napi_deferred deferred;
     napi_async_work async_work;
     /* output */
-    jv result;
+    bool is_undefined;
+    std::string result;
     std::string error;
     bool success;
 };
@@ -466,8 +483,8 @@ void ExecuteAsync(napi_env env, void* data) {
         work->error = "Invalid JSON input";
         work->success = false;
         jv_free(input);
+        cache.dec_refcnt(wrapper);
         wrapper->unlock();
-        cache.set_item_in_use_false(wrapper);
 
         return;
     }
@@ -476,14 +493,43 @@ void ExecuteAsync(napi_env env, void* data) {
     ASYNC_DEBUG_LOG(work, "jq execution started");
 
     jv result=jq_next(wrapper->get_jq());
-    work->result = result;
-    work->success = true;
+    if(jv_get_kind(result) == JV_KIND_INVALID){
+        jv msg = jv_invalid_get_msg(jv_copy(result));
+
+        if (jv_get_kind(msg) == JV_KIND_STRING) {
+            work->error = std::string("jq: error: ") + jv_string_value(msg);
+            jv_free(msg);
+            work->success=false;
+        }else{
+            work->is_undefined = true;
+            work->success=true;
+        }
+    }else{
+        jv dump  = jv_dump_string(result, JV_PRINT_INVALID);
+        if(jv_is_valid(dump)){
+            work->result = jv_string_value(dump);
+            work->success = true;
+        }else{
+            ASYNC_DEBUG_LOG(work, "failed to get result");
+            work->error = "failed to get result";
+            work->success = false;
+        }
+        jv_free(dump);
+    }
     wrapper->unlock();
+    cache.dec_refcnt(wrapper);
 
-    cache.set_item_in_use_false(wrapper);
-    ASYNC_DEBUG_LOG(work, "jq execution finished - got result, %p", work->result);
+    ASYNC_DEBUG_LOG(work, "jq execution finished - got result, %s", work->result.c_str());
 }
 
+void reject_with_error_message(napi_env env, napi_deferred deferred, std::string error_message){
+    napi_value error;
+    napi_create_string_utf8(env, error_message.c_str(), NAPI_AUTO_LENGTH, &error);
+    napi_value error_obj;
+    napi_create_object(env, &error_obj);
+    napi_set_named_property(env, error_obj, "message", error);
+    napi_reject_deferred(env, deferred, error_obj);
+}
 
 void CompleteAsync(napi_env env, napi_status status, void* data) {
     AsyncWork* work = static_cast<AsyncWork*>(data);
@@ -491,69 +537,50 @@ void CompleteAsync(napi_env env, napi_status status, void* data) {
 
     auto cleanup = [&]() {
         if (!cleanup_done) {
-            DEBUG_LOG("Freeing result, %p,refcnt %zu", work->result, jv_get_refcnt(work->result));
-            jv_free(work->result);
             napi_delete_async_work(env, work->async_work);
             ASYNC_DEBUG_LOG(work, "Deleting AsyncWork");
             delete work;
             cleanup_done = true;
         }
     };
-    if(status != napi_ok){
-        napi_throw_type_error(env, nullptr, "Got error from async work");
-        napi_reject_deferred(env, work->deferred, nullptr);
+
+    if(status != napi_ok || !work->success){
+        std::string error_message = work->error;
+        if(error_message == ""){
+            error_message = "Got error from async work";
+        }
+        reject_with_error_message(env, work->deferred, error_message);
         cleanup();
         return;
     }
     napi_handle_scope scope;
-     status = napi_open_handle_scope(env, &scope);
+    status = napi_open_handle_scope(env, &scope);
     if (status != napi_ok) {
-        napi_throw_type_error(env, nullptr, "Failed to create handle scope");
-        napi_reject_deferred(env, work->deferred, nullptr);
+        reject_with_error_message(env, work->deferred, "Failed to create handle scope");
         cleanup();
         return;
     }
 
-    if (work->success) {
         napi_value ret;
 
         status=napi_create_object(env, &ret);
-        if(status != napi_ok){
-            napi_throw_error(env, nullptr, "Failed to create object");
-            napi_close_handle_scope(env, scope);
-            napi_resolve_deferred(env, work->deferred, ret);
-            cleanup();
-            return;
+
+        jv result_jv;
+        if(work->is_undefined){
+            result_jv = jv_invalid();
+        }else{
+            result_jv= jv_parse(work->result.c_str());
         }
-        DEBUG_LOG("[COMPLETE ASYNC][%p] result %p", work, work->result);
         std::string err_msg_conversion;
-        bool success = jv_object_to_napi("value", env, work->result, ret,err_msg_conversion);
-        if(!success){
-            napi_value error;
-            napi_create_string_utf8(env, err_msg_conversion.c_str(), NAPI_AUTO_LENGTH, &error);
-
-            napi_value error_obj;
-            napi_create_object(env, &error_obj);
-            napi_set_named_property(env, error_obj, "message", error);
-            // napi_create_error(env, nullptr, error, &error_obj);
-            napi_reject_deferred(env, work->deferred, error_obj);
+        bool success = jv_object_to_napi("value", env, result_jv, ret,err_msg_conversion);
+        jv_free(result_jv);
 
-            jv_free(work->result);
+        if(!success){
+            reject_with_error_message(env, work->deferred, err_msg_conversion);
             napi_close_handle_scope(env, scope);
             return;
         }
         napi_resolve_deferred(env, work->deferred, ret);
-    } else {
-        napi_value error;
-        napi_create_string_utf8(env, work->error.c_str(), NAPI_AUTO_LENGTH, &error);
-
-        napi_value error_obj;
-        napi_create_object(env, &error_obj);
-        napi_set_named_property(env, error_obj, "message", error);
-
-        // napi_create_error(env, nullptr, error, &error_obj);
-        napi_reject_deferred(env, work->deferred, error_obj);
-    }
     cleanup();
     napi_close_handle_scope(env, scope);
 }
@@ -598,26 +625,26 @@ napi_value ExecAsync(napi_env env, napi_callback_info info) {
     return promise;
 }
 
-napi_value SetDebugMode(napi_env env, napi_callback_info info) {
-    size_t argc = 1;
-    napi_value args[1];
-    bool enable;
+// napi_value SetDebugMode(napi_env env, napi_callback_info info) {
+//     size_t argc = 1;
+//     napi_value args[1];
+//     bool enable;
     
-    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+//     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
     
-    if (argc < 1) {
-        napi_throw_type_error(env, nullptr, "Wrong number of arguments");
-        return nullptr;
-    }
+//     if (argc < 1) {
+//         napi_throw_type_error(env, nullptr, "Wrong number of arguments");
+//         return nullptr;
+//     }
     
-    napi_get_value_bool(env, args[0], &enable);
-    debug_enabled = enable;
-    DEBUG_LOG("Debug mode %s", enable ? "enabled" : "disabled");
+//     napi_get_value_bool(env, args[0], &enable);
+//     debug_enabled = enable;
+//     DEBUG_LOG("Debug mode %s", enable ? "enabled" : "disabled");
     
-    napi_value result;
-    napi_get_boolean(env, debug_enabled, &result);
-    return result;
-}
+//     napi_value result;
+//     napi_get_boolean(env, debug_enabled, &result);
+//     return result;
+// }
 
 // napi_value GetCacheStats(napi_env env, napi_callback_info info) {
 //     napi_value result;
@@ -663,16 +690,16 @@ napi_value SetCacheSize(napi_env env, napi_callback_info info) {
 }
 
 napi_value Init(napi_env env, napi_value exports) {
-    napi_value exec_sync, exec_async, debug_fn, cache_size_fn,cache_stats_fn;
+    napi_value exec_sync, exec_async, cache_size_fn,cache_stats_fn;
 
     napi_create_function(env, "execSync", NAPI_AUTO_LENGTH, ExecSync, nullptr, &exec_sync);
     napi_create_function(env, "execAsync", NAPI_AUTO_LENGTH, ExecAsync, nullptr, &exec_async);
-    napi_create_function(env, "setDebugMode", NAPI_AUTO_LENGTH, SetDebugMode, nullptr, &debug_fn);
+    // napi_create_function(env, "setDebugMode", NAPI_AUTO_LENGTH, SetDebugMode, nullptr, &debug_fn);
     napi_create_function(env, "setCacheSize", NAPI_AUTO_LENGTH, SetCacheSize, nullptr, &cache_size_fn);
     // napi_create_function(env, "getCacheStats", NAPI_AUTO_LENGTH, GetCacheStats, nullptr, &cache_stats_fn);
     napi_set_named_property(env, exports, "execSync", exec_sync);
     napi_set_named_property(env, exports, "execAsync", exec_async);
-    napi_set_named_property(env, exports, "setDebugMode", debug_fn);
+    // napi_set_named_property(env, exports, "setDebugMode", debug_fn);
     napi_set_named_property(env, exports, "setCacheSize", cache_size_fn);
     // napi_set_named_property(env, exports, "getCacheStats", cache_stats_fn);
     return exports;

package/test/template.test.js

@@ -44,7 +44,6 @@ describe('template', () => {
         const json = "foo";
         const input = '{{.foo}}';
         const result = jq.renderRecursively(json, input);
-        console.log('!!!!!',result);
         expect(result).toBe(null);
     });
     it('should excape \'\' to ""', () => {