@port-labs/jq-node-bindings 0.0.11 → 0.0.13

package/index.d.ts

@@ -1,6 +1,12 @@
 declare module '@port-labs/jq-node-bindings' {
   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

@@ -6,6 +6,14 @@ const formatFilter = (filter, {enableEnv = false} = {}) => {
   // Conditionally enable access to env
   return enableEnv ? formattedFilter : `def env: {}; {} as $ENV | ${formattedFilter}`;
 }
+
+
+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, {enableEnv}))
@@ -13,12 +21,14 @@ const exec = (object, filter, {enableEnv = false, throwOnError = false} = {}) =>
     return data?.value;
   } catch (err) {
     if (throwOnError) {
-      throw err;
+      throw new (err?.message?.startsWith('jq: compile error') ? JqExecCompileError : JqExecError)(err.message);
     }
     return null
   }
 }
 
 module.exports = {
-  exec
+  exec,
+  JqExecError,
+  JqExecCompileError
 };

package/lib/template.js

@@ -93,6 +93,19 @@ const renderRecursively = (inputJson, template, execOptions = {}) => {
   if (typeof template === 'object' && template !== null) {
     return Object.fromEntries(
       Object.entries(template).flatMap(([key, value]) => {
+        const SPREAD_KEYWORD = "spreadValue";
+        const keywordMatcher = `^\\{\\{\\s*${SPREAD_KEYWORD}\\(\\s*\\)\\s*\\}\\}$`;  // matches {{ <Keyword>() }} with white spaces where you'd expect them
+
+        if (key.trim().match(keywordMatcher)) {
+          const evaluatedValue = renderRecursively(inputJson, value, execOptions);
+          if (typeof evaluatedValue !== "object") {
+            throw new Error(
+              `Evaluated value should be an object if the key is ${key}. Original value: ${value}, evaluated to: ${JSON.stringify(evaluatedValue)}`
+            );
+          }
+          return Object.entries(evaluatedValue);
+        }
+
         const evaluatedKey = renderRecursively(inputJson, key, execOptions);
         if (!['undefined', 'string'].includes(typeof evaluatedKey) && evaluatedKey !== null) {
           throw new Error(

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@port-labs/jq-node-bindings",
-  "version": "v0.0.11",
+  "version": "v0.0.13",
   "description": "Node.js bindings for JQ",
-  "jq-node-bindings": "0.0.11",
+  "jq-node-bindings": "0.0.13",
   "main": "lib/index.js",
   "scripts": {
     "configure": "node-gyp configure",

package/src/binding.cc

@@ -63,7 +63,7 @@ void jv_object_to_v8(std::string key, jv actual, v8::Local<v8::Object> ret) {
             snprintf(err, sizeof(err), "jq: error: %s", jv_string_value(msg));
             jv_free(msg);
             jv_free(actual);
-            Nan::ThrowTypeError(err);
+            Nan::ThrowError(err);
             return;
           }
           jv_free(msg);
@@ -127,7 +127,7 @@ void throw_err_cb(void *data, jv msg) {
   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), "%s", jv_string_value(msg));
+    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);
@@ -143,7 +143,7 @@ void jq_exec(std::string json, std::string filter,const Nan::FunctionCallbackInf
         jq = jq_init();
         jq_set_error_cb(jq, throw_err_cb, &err_msg);
         if (!jq_compile(jq, filter.c_str())) {
-            Nan::ThrowTypeError(err_msg.buf);
+            Nan::ThrowError(err_msg.buf);
             return;
         }
         cache.put(filter, jq);

package/test/santiy.test.js

@@ -159,11 +159,11 @@ describe('jq', () => {
     })
 
     it('test throw on error', () => {
-        expect(() => { jq.exec({}, 'foo', {throwOnError: true}) }).toThrow("jq: error: foo/0 is not defined at <top-level>, line 1:");
-        expect(() => { jq.exec({}, '1/0', {throwOnError: true}) }).toThrow("jq: error: Division by zero? at <top-level>, line 1:");
-        expect(() => { jq.exec({}, '{', {throwOnError: true}) }).toThrow("jq: error: syntax error, unexpected $end (Unix shell quoting issues?) at <top-level>, line 1:");
-        expect(() => { jq.exec({}, '{(0):1}', {throwOnError: true}) }).toThrow("jq: 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: error: Possibly unterminated 'if' statement at <top-level>, line 1:");
+        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

@@ -125,6 +125,14 @@ describe('template', () => {
         expect(render({'{{""}}': 'bar'})).toEqual({});
         expect(render({'{{\'\'}}': 'bar'})).toEqual({});
     });
+    it('testing spread key', () => {
+        const json = { foo: "bar" };
+        const render = (input) => jq.renderRecursively(json, input);
+
+        expect(render({ "{{spreadValue()}}": { foo: "bar" } })).toEqual({foo: "bar"});
+        expect(render({ " {{ spreadValue( ) }} ": { foo: "bar" } })).toEqual({foo: "bar"});
+        expect(render({ "{{spreadValue()}}": "{{ . }}" })).toEqual({ foo: "bar" });
+    });
     it('recursive templates should work', () => {
         const json = { foo: 'bar', bar: 'foo' };
         const render = (input) => jq.renderRecursively(json, input);
@@ -156,15 +164,19 @@ describe('template', () => {
         expect(jq.renderRecursively({}, '{{env}}')).toEqual({});
     })
     it('test throw on error', () => {
-        expect(() => { jq.renderRecursively({}, '{{foo}}', {throwOnError: true}) }).toThrow("jq: error: foo/0 is not defined at <top-level>, line 1:");
-        expect(() => { jq.renderRecursively({}, '{{1/0}}', {throwOnError: true}) }).toThrow("jq: error: Division by zero? at <top-level>, line 1:");
-        expect(() => { jq.renderRecursively({}, '{{{}}', {throwOnError: true}) }).toThrow("jq: error: syntax error, unexpected $end (Unix shell quoting issues?) at <top-level>, line 1:");
-        expect(() => { jq.renderRecursively({}, '{{ {(0):1} }}', {throwOnError: true}) }).toThrow("jq: 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: error: Possibly unterminated 'if' statement 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:");
+        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: error: foo/0 is not defined at <top-level>, line 1:");
-        expect(() => { jq.renderRecursively({}, '/{{foo}}/', {throwOnError: true}) }).toThrow("jq: error: foo/0 is not defined at <top-level>, line 1:");
+        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:");
+        expect(() => { jq.renderRecursively({}, { "{{ spreadValue() }}": "str" }, { throwOnError: true }) })
+            .toThrow('Evaluated value should be an object if the key is {{ spreadValue() }}. Original value: str, evaluated to: "str"');
+        expect(() => { jq.renderRecursively({}, { "{{ spreadValue() }}": "{{ \"str\" }}" }, { throwOnError: true }) })
+            .toThrow('Evaluated value should be an object if the key is {{ spreadValue() }}. Original value: {{ \"str\" }}, evaluated to: "str"');
     })
 })