@port-labs/jq-node-bindings 0.0.10 → 0.0.12

package/index.d.ts

@@ -1,4 +1,13 @@
 declare module '@port-labs/jq-node-bindings' {
-    export function exec(json: object, input: string, options?: {enableEnv?: boolean}): object | Array<any> | string | number | boolean | null;
-    export function renderRecursively(json: object, input: object | Array<any> | string | number | boolean | null): object | Array<any> | string | number | boolean | null;
+  type ExecOptions = { enableEnv?: boolean, throwOnError?: boolean };
+
+  export class JqExecError extends Error {
+  }
+
+  export class JqExecCompileError extends Error {
+  }
+
+  export function exec(json: object, input: string, options?: ExecOptions): object | Array<any> | string | number | boolean | null;
+
+  export function renderRecursively(json: object, input: object | Array<any> | string | number | boolean | null, execOptions?: ExecOptions): object | Array<any> | string | number | boolean | null;
 }

package/lib/index.js

@@ -4,5 +4,7 @@ const template = require('./template');
 
 module.exports = {
   exec: jq.exec,
-  renderRecursively: template.renderRecursively
+  renderRecursively: template.renderRecursively,
+  JqExecError: jq.JqExecError,
+  JqExecCompileError: jq.JqExecCompileError,
 };

package/lib/jq.js

@@ -1,21 +1,34 @@
 const nativeJq = require('bindings')('jq-node-bindings')
 
-const formatFilter = (filter, options) => {
+const formatFilter = (filter, {enableEnv = false} = {}) => {
   // Escape single quotes only if they are opening or closing a string
   let formattedFilter = filter.replace(/(^|\s)'(?!\s|")|(?<!\s|")'(\s|$)/g, '$1"$2');
   // Conditionally enable access to env
-  return options.enableEnv ? formattedFilter: `def env: {}; {} as $ENV | ${formattedFilter}`;
+  return enableEnv ? formattedFilter : `def env: {}; {} as $ENV | ${formattedFilter}`;
 }
-const exec = (object, filter, options = { enableEnv: false }) => {
+
+
+class JqExecError extends Error {
+}
+
+class JqExecCompileError extends JqExecError {
+}
+
+const exec = (object, filter, {enableEnv = false, throwOnError = false} = {}) => {
   try {
-    const data = nativeJq.exec(JSON.stringify(object), formatFilter(filter, options))
+    const data = nativeJq.exec(JSON.stringify(object), formatFilter(filter, {enableEnv}))
 
     return data?.value;
   } catch (err) {
+    if (throwOnError) {
+      throw new (err?.message?.startsWith('jq: compile error') ? JqExecCompileError : JqExecError)(err.message);
+    }
     return null
   }
 }
 
 module.exports = {
-  exec
+  exec,
+  JqExecError,
+  JqExecCompileError
 };

package/lib/template.js

@@ -51,7 +51,7 @@ const findInsideDoubleBracesIndices = (input) => {
   return indices;
 }
 
-const render = (inputJson, template) => {
+const render = (inputJson, template, execOptions = {}) => {
   if (typeof template !== 'string') {
     return null;
   }
@@ -64,12 +64,12 @@ const render = (inputJson, template) => {
   const firstIndex = indices[0];
   if (indices.length === 1 && template.trim().startsWith('{{') && template.trim().endsWith('}}')) {
     // If entire string is a template, evaluate and return the result with the original type
-    return jq.exec(inputJson, template.slice(firstIndex.start, firstIndex.end));
+    return jq.exec(inputJson, template.slice(firstIndex.start, firstIndex.end), execOptions);
   }
 
   let result = template.slice(0, firstIndex.start - '{{'.length); // Initiate result with string until first template start index
   indices.forEach((index, i) => {
-    const jqResult = jq.exec(inputJson, template.slice(index.start, index.end));
+    const jqResult = jq.exec(inputJson, template.slice(index.start, index.end), execOptions);
     result +=
       // Add to the result the stringified evaluated jq of the current template
       (typeof jqResult === 'string' ? jqResult : JSON.stringify(jqResult)) +
@@ -83,24 +83,24 @@ const render = (inputJson, template) => {
   return result;
 }
 
-const renderRecursively = (inputJson, template) => {
+const renderRecursively = (inputJson, template, execOptions = {}) => {
   if (typeof template === 'string') {
-    return render(inputJson, template);
+    return render(inputJson, template, execOptions);
   }
   if (Array.isArray(template)) {
-    return template.map((value) => renderRecursively(inputJson, value));
+    return template.map((value) => renderRecursively(inputJson, value, execOptions));
   }
   if (typeof template === 'object' && template !== null) {
     return Object.fromEntries(
-        Object.entries(template).flatMap(([key, value]) => {
-          const evaluatedKey = renderRecursively(inputJson, key);
-          if (!['undefined', 'string'].includes(typeof evaluatedKey) && evaluatedKey !== null) {
-            throw new Error(
-                `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(evaluatedKey)}`,
-            );
-          }
-          return evaluatedKey ? [[evaluatedKey, renderRecursively(inputJson, value)]] : [];
-        }),
+      Object.entries(template).flatMap(([key, value]) => {
+        const evaluatedKey = renderRecursively(inputJson, key, execOptions);
+        if (!['undefined', 'string'].includes(typeof evaluatedKey) && evaluatedKey !== null) {
+          throw new Error(
+            `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(evaluatedKey)}`,
+          );
+        }
+        return evaluatedKey ? [[evaluatedKey, renderRecursively(inputJson, value, execOptions)]] : [];
+      }),
     );
   }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@port-labs/jq-node-bindings",
-  "version": "v0.0.10",
+  "version": "v0.0.12",
   "description": "Node.js bindings for JQ",
-  "jq-node-bindings": "0.0.10",
+  "jq-node-bindings": "0.0.12",
   "main": "lib/index.js",
   "scripts": {
     "configure": "node-gyp configure",

package/src/binding.cc

@@ -56,6 +56,20 @@ void jv_object_to_v8(std::string key, jv actual, v8::Local<v8::Object> ret) {
     v8::Local<v8::Value> v8_val;
 
     switch (k) {
+      case JV_KIND_INVALID: {
+          jv msg = jv_invalid_get_msg(jv_copy(actual));
+          char err[4096];
+          if (jv_get_kind(msg) == JV_KIND_STRING) {
+            snprintf(err, sizeof(err), "jq: error: %s", jv_string_value(msg));
+            jv_free(msg);
+            jv_free(actual);
+            Nan::ThrowError(err);
+            return;
+          }
+          jv_free(msg);
+          jv_free(actual);
+          break;
+      }
       case JV_KIND_NULL: {
           v8_val = Nan::Null();
           break;
@@ -104,40 +118,55 @@ void jv_object_to_v8(std::string key, jv actual, v8::Local<v8::Object> ret) {
     Nan::Set(ret, v8_key, v8_val);
 }
 
+struct err_data {
+  char buf[4096];
+};
+
+void throw_err_cb(void *data, jv msg) {
+  struct err_data *err_data = (struct err_data *)data;
+  if (jv_get_kind(msg) != JV_KIND_STRING)
+    msg = jv_dump_string(msg, JV_PRINT_INVALID);
+  if (!strncmp(jv_string_value(msg), "jq: error", sizeof("jq: error") - 1))
+    snprintf(err_data->buf, sizeof(err_data->buf), "jq: compile error%s", jv_string_value(msg) + strlen("jq: error"));
+  if (strchr(err_data->buf, '\n'))
+    *(strchr(err_data->buf, '\n')) = '\0';
+  jv_free(msg);
+}
+
 void jq_exec(std::string json, std::string filter,const Nan::FunctionCallbackInfo<v8::Value>& info) {
     jq_state *jq = NULL;
+    struct err_data err_msg;
 
     if (cache.exist(filter)) {
         jq = cache.get(filter);
     } else {
         jq = jq_init();
+        jq_set_error_cb(jq, throw_err_cb, &err_msg);
         if (!jq_compile(jq, filter.c_str())) {
-            info.GetReturnValue().Set(Nan::Null());
+            Nan::ThrowError(err_msg.buf);
             return;
         }
         cache.put(filter, jq);
     }
 
-    jv input = jv_parse(json.c_str());
-
-    if (!jv_is_valid(input)) {
+    if (jq == NULL) {
         info.GetReturnValue().Set(Nan::Null());
         return;
     }
 
-    if (jq == NULL) {
+    jv input = jv_parse(json.c_str());
+
+    if (!jv_is_valid(input)) {
         info.GetReturnValue().Set(Nan::Null());
+        jv_free(input);
         return;
     }
 
     jq_start(jq, input, 0);
-
-    jv actual = jq_next(jq);
-    jv_kind k = jv_get_kind(actual);
+    jv result = jq_next(jq);
 
     v8::Local<v8::Object> ret = Nan::New<v8::Object>();
-
-    jv_object_to_v8("value", actual, ret);
+    jv_object_to_v8("value", result, ret);
 
     info.GetReturnValue().Set(ret);
 }
@@ -149,14 +178,14 @@ std::string FromV8String(v8::Local<v8::String> val) {
 }
 
 void Exec(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-        v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
-
         if (info.Length() < 2) {
             Nan::ThrowTypeError("Wrong number of arguments");
+            return;
         }
 
         if (!info[0]->IsString() || !info[1]->IsString()) {
             Nan::ThrowTypeError("Wrong arguments");
+            return;
         }
 
         std::string json = FromV8String(Nan::To<v8::String>(info[0]).ToLocalChecked());
@@ -166,12 +195,10 @@ void Exec(const Nan::FunctionCallbackInfo<v8::Value>& info) {
 }
 
 void Init(v8::Local<v8::Object> exports) {
-  v8::Local<v8::Context> context = exports->CreationContext();
-  exports->Set(context,
-               Nan::New("exec").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(Exec)
-                   ->GetFunction(context)
-                   .ToLocalChecked());
+  v8::Local<v8::Context> context = exports->GetCreationContext().ToLocalChecked();
+  (void)exports->Set(context,
+                     Nan::New("exec").ToLocalChecked(),
+                     Nan::New<v8::FunctionTemplate>(Exec)->GetFunction(context).ToLocalChecked());
 }
 
 NODE_MODULE(exec, Init)

package/test/santiy.test.js

@@ -3,7 +3,7 @@ const jq = require('../lib');
 describe('jq', () => {
     it('should break', () => {
         const json = { foo2: 'bar' };
-        const input = '.foo';
+        const input = 'foo';
         const result = jq.exec(json, input);
 
         expect(result).toBe(null);
@@ -116,7 +116,7 @@ describe('jq', () => {
         const input = '.foo';
         const result = jq.exec(json, input);
 
-        expect(result).toBe(undefined);
+        expect(result).toBe(null);
     })
 
     it('should excape \'\' to ""', () => {
@@ -157,5 +157,15 @@ describe('jq', () => {
         expect(jq.exec({}, 'env', {})).toEqual({});
         expect(jq.exec({}, 'env')).toEqual({});
     })
+
+    it('test throw on error', () => {
+        expect(() => { jq.exec({}, 'foo', {throwOnError: true}) }).toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(() => { jq.exec({}, '1/0', {throwOnError: true}) }).toThrow("jq: compile error: Division by zero? at <top-level>, line 1:");
+        expect(() => { jq.exec({}, '{', {throwOnError: true}) }).toThrow("jq: compile error: syntax error, unexpected $end (Unix shell quoting issues?) at <top-level>, line 1:");
+        expect(() => { jq.exec({}, '{(0):1}', {throwOnError: true}) }).toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
+        expect(() => { jq.exec({}, 'if true then 1 else 0', {throwOnError: true}) }).toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
+        expect(() => { jq.exec({}, 'null | map(.+1)', {throwOnError: true}) }).toThrow("jq: error: Cannot iterate over null (null)");
+        expect(() => { jq.exec({foo: "bar"}, '.foo + 1', {throwOnError: true}) }).toThrow("jq: error: string (\"bar\") and number (1) cannot be added");
+    })
 })
 

package/test/template.test.js

@@ -45,7 +45,7 @@ describe('template', () => {
         const input = '{{.foo}}';
         const result = jq.renderRecursively(json, input);
 
-        expect(result).toBe(undefined);
+        expect(result).toBe(null);
     });
     it('should excape \'\' to ""', () => {
         const json = { foo: 'com' };
@@ -149,5 +149,22 @@ describe('template', () => {
 
         expect(render('{{"\\"foo\\""}}')).toEqual('"foo"');
     });
+    it('test disable env', () => {
+        expect(jq.renderRecursively({}, '{{env}}', {enableEnv: false})).toEqual({});
+        expect(jq.renderRecursively({}, '{{env}}', {enableEnv: true})).not.toEqual({});
+        expect(jq.renderRecursively({}, '{{env}}', {})).toEqual({});
+        expect(jq.renderRecursively({}, '{{env}}')).toEqual({});
+    })
+    it('test throw on error', () => {
+        expect(() => { jq.renderRecursively({}, '{{foo}}', {throwOnError: true}) }).toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '{{1/0}}', {throwOnError: true}) }).toThrow("jq: compile error: Division by zero? at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '{{{}}', {throwOnError: true}) }).toThrow("jq: compile error: syntax error, unexpected $end (Unix shell quoting issues?) at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '{{ {(0):1} }}', {throwOnError: true}) }).toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '{{if true then 1 else 0}}', {throwOnError: true}) }).toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '{{null | map(.+1)}}', {throwOnError: true}) }).toThrow("jq: error: Cannot iterate over null (null)");
+        expect(() => { jq.renderRecursively({foo: "bar"}, '{{.foo + 1}}', {throwOnError: true}) }).toThrow("jq: error: string (\"bar\") and number (1) cannot be added");
+        expect(() => { jq.renderRecursively({}, '{{foo}}/{{bar}}', {throwOnError: true}) }).toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '/{{foo}}/', {throwOnError: true}) }).toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+    })
 })