@port-labs/jq-node-bindings 1.1.0-dev → 1.1.0-dev.1

package/lib/index.js

@@ -1,11 +1,12 @@
-const jq = require('./jq');
-const template = require('./template');
-const templateAsync = require('./templateAsync');
-
+const jq = require("./jq");
+const template = require("./template");
+const templateAsync = require("./templateAsync");
 
 module.exports = {
   exec: jq.exec,
   execAsync: jq.execAsync,
+  execRaw: jq.execRaw,
+  execRawAsync: jq.execRawAsync,
   setCacheSize: jq.setCacheSize,
   renderRecursively: template.renderRecursively,
   renderRecursivelyAsync: templateAsync.renderRecursivelyAsync,

package/lib/jq.js

@@ -1,47 +1,83 @@
-const nativeJq = require('bindings')('jq-node-bindings')
-nativeJq.setCacheSize(1000)
+const nativeJq = require("bindings")("jq-node-bindings");
+nativeJq.setCacheSize(1000);
 
-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 enableEnv ? formattedFilter : `def env: {}; {} as $ENV | ${formattedFilter}`;
-}
+const SINGLE_QUOTE_RE = /(^|\s)'(?!\s|")|(?<!\s|")'(\s|$)/g;
+const COMPILE_ERROR_PREFIX = "jq: compile error";
+const ENV_DISABLE_PREFIX = "def env: {}; {} as $ENV | ";
 
+const formatFilter = (filter, enableEnv) => {
+  const formattedFilter = filter.replace(SINGLE_QUOTE_RE, '$1"$2');
+  return enableEnv ? formattedFilter : ENV_DISABLE_PREFIX + formattedFilter;
+};
 
-class JqExecError extends Error {
-}
+class JqExecError extends Error {}
 
-class JqExecCompileError extends JqExecError {
-}
+class JqExecCompileError extends JqExecError {}
 
-const exec = (object, filter, {enableEnv = false, throwOnError = false} = {}) => {
+const execRaw = (jsonStr, filter, execOptions) => {
   try {
-    const data = nativeJq.execSync(JSON.stringify(object), formatFilter(filter, {enableEnv}))
-
+    const data = nativeJq.execSync(
+      jsonStr,
+      formatFilter(filter, execOptions.enableEnv)
+    );
     return data?.value;
   } catch (err) {
-    if (throwOnError) {
-      throw new (err?.message?.startsWith('jq: compile error') ? JqExecCompileError : JqExecError)(err.message);
+    if (execOptions.throwOnError) {
+      const msg = err?.message;
+      throw new (
+        msg && msg.startsWith(COMPILE_ERROR_PREFIX)
+          ? JqExecCompileError
+          : JqExecError
+      )(msg);
     }
-    return null
+    return null;
   }
-}
+};
 
-const execAsync = async (object, filter, {enableEnv = false, throwOnError = false, timeoutSec} = {}) => {
+const execRawAsync = async (jsonStr, filter, execOptions) => {
   try {
-    const data = await nativeJq.execAsync(JSON.stringify(object), formatFilter(filter, {enableEnv}), timeoutSec)
+    const data = await nativeJq.execAsync(
+      jsonStr,
+      formatFilter(filter, execOptions.enableEnv),
+      execOptions.timeoutSec
+    );
     return data?.value;
   } catch (err) {
-    if (throwOnError) {
-      throw new (err?.message?.startsWith('jq: compile error') ? JqExecCompileError : JqExecError)(err.message);
+    if (execOptions.throwOnError) {
+      const msg = err?.message;
+      throw new (
+        msg && msg.startsWith(COMPILE_ERROR_PREFIX)
+          ? JqExecCompileError
+          : JqExecError
+      )(msg);
     }
-    return null
+    return null;
   }
-}
+};
+
+const DEFAULT_OPTIONS = { enableEnv: false, throwOnError: false };
+
+const exec = (object, filter, execOptions) => {
+  return execRaw(
+    JSON.stringify(object),
+    filter,
+    execOptions || DEFAULT_OPTIONS
+  );
+};
+
+const execAsync = async (object, filter, execOptions) => {
+  return execRawAsync(
+    JSON.stringify(object),
+    filter,
+    execOptions || DEFAULT_OPTIONS
+  );
+};
+
 module.exports = {
   exec,
   execAsync,
+  execRaw,
+  execRawAsync,
   setCacheSize: nativeJq.setCacheSize,
   JqExecError,
   JqExecCompileError,

package/lib/parse.js

@@ -0,0 +1,79 @@
+const CH_BACKSLASH = 92; // '\'
+const CH_DOUBLE_QUOTE = 34; // '"'
+const CH_SINGLE_QUOTE = 39; // "'"
+const CH_OPEN_BRACE = 123; // '{'
+const CH_CLOSE_BRACE = 125; // '}'
+
+const findInsideDoubleBracesIndices = (input) => {
+  let wrappingQuote = 0;
+  let insideDoubleBracesStart = -1;
+  const indices = [];
+  const len = input.length;
+
+  for (let i = 0; i < len; i++) {
+    const cc = input.charCodeAt(i);
+
+    if (insideDoubleBracesStart !== -1 && cc === CH_BACKSLASH) {
+      i++;
+      continue;
+    }
+    if (
+      insideDoubleBracesStart !== -1 &&
+      (cc === CH_DOUBLE_QUOTE || cc === CH_SINGLE_QUOTE)
+    ) {
+      if (!wrappingQuote) {
+        wrappingQuote = cc;
+      } else if (wrappingQuote === cc) {
+        wrappingQuote = 0;
+      }
+    } else if (
+      !wrappingQuote &&
+      cc === CH_OPEN_BRACE &&
+      i > 0 &&
+      input.charCodeAt(i - 1) === CH_OPEN_BRACE
+    ) {
+      if (insideDoubleBracesStart !== -1) {
+        throw new Error(
+          `Found double braces in index ${i - 1} inside other one in index ${
+            insideDoubleBracesStart - 2
+          }`
+        );
+      }
+      insideDoubleBracesStart = i + 1;
+      if (i + 1 < len && input.charCodeAt(i + 1) === CH_OPEN_BRACE) {
+        i++;
+      }
+    } else if (
+      !wrappingQuote &&
+      cc === CH_CLOSE_BRACE &&
+      i > 0 &&
+      input.charCodeAt(i - 1) === CH_CLOSE_BRACE
+    ) {
+      if (insideDoubleBracesStart !== -1) {
+        indices.push({ start: insideDoubleBracesStart, end: i - 1 });
+        insideDoubleBracesStart = -1;
+        if (i + 1 < len && input.charCodeAt(i + 1) === CH_CLOSE_BRACE) {
+          i++;
+        }
+      } else {
+        throw new Error(
+          `Found closing double braces in index ${
+            i - 1
+          } without opening double braces`
+        );
+      }
+    }
+  }
+
+  if (insideDoubleBracesStart !== -1) {
+    throw new Error(
+      `Found opening double braces in index ${
+        insideDoubleBracesStart - 2
+      } without closing double braces`
+    );
+  }
+
+  return indices;
+};
+
+module.exports = findInsideDoubleBracesIndices;

package/lib/template.js

@@ -1,125 +1,123 @@
-const jq = require('./jq');
+const jq = require("./jq");
+const findInsideDoubleBracesIndices = require("./parse");
 
-const findInsideDoubleBracesIndices = (input) => {
-  let wrappingQuote = null;
-  let insideDoubleBracesStart = null;
-  const indices = [];
+const CH_OPEN_BRACE = 123; // '{'
+const CH_CLOSE_BRACE = 125; // '}'
+const BRACE_PAIR_LEN = 2; // length of '{{' or '}}'
 
-  for (let i = 0; i < input.length; i += 1) {
-    const char = input[i];
+const SPREAD_KEYWORD_PATTERN = /^\s*\{\{\s*spreadValue\(\s*\)\s*\}\}\s*$/;
 
-    if (insideDoubleBracesStart && char === '\\') {
-      // If next character is escaped, skip it
-      i += 1;
-    }
-    if (insideDoubleBracesStart && (char === '"' || char === "'")) {
-      // If inside double braces and inside quotes, ignore braces
-      if (!wrappingQuote) {
-        wrappingQuote = char;
-      } else if (wrappingQuote === char) {
-        wrappingQuote = null;
-      }
-    } else if (!wrappingQuote && char === '{' && i > 0 && input[i - 1] === '{') {
-      // if opening double braces that not wrapped with quotes
-      if (insideDoubleBracesStart) {
-        throw new Error(`Found double braces in index ${i - 1} inside other one in index ${insideDoubleBracesStart - '{{'.length}`);
-      }
-      insideDoubleBracesStart = i + 1;
-      if (input[i + 1] === '{') {
-        // To overcome three "{" in a row considered as two different opening double braces
-        i += 1;
-      }
-    } else if (!wrappingQuote && char === '}' && i > 0 && input[i - 1] === '}') {
-      // if closing double braces that not wrapped with quotes
-      if (insideDoubleBracesStart) {
-        indices.push({start: insideDoubleBracesStart, end: i - 1});
-        insideDoubleBracesStart = null;
-        if (input[i + 1] === '}') {
-          // To overcome three "}" in a row considered as two different closing double braces
-          i += 1;
-        }
-      } else {
-        throw new Error(`Found closing double braces in index ${i - 1} without opening double braces`);
-      }
-    }
-  }
-
-  if (insideDoubleBracesStart) {
-    throw new Error(`Found opening double braces in index ${insideDoubleBracesStart - '{{'.length} without closing double braces`);
-  }
-
-  return indices;
-}
-
-const render = (inputJson, template, execOptions = {}) => {
-  if (typeof template !== 'string') {
+const render = (jsonStr, template, execOptions) => {
+  if (typeof template !== "string") {
     return null;
   }
   const indices = findInsideDoubleBracesIndices(template);
   if (!indices.length) {
-    // If no jq templates in string, return it
     return 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), execOptions);
+  if (indices.length === 1) {
+    const trimmed = template.trim();
+    if (
+      trimmed.charCodeAt(0) === CH_OPEN_BRACE &&
+      trimmed.charCodeAt(1) === CH_OPEN_BRACE &&
+      trimmed.charCodeAt(trimmed.length - 1) === CH_CLOSE_BRACE &&
+      trimmed.charCodeAt(trimmed.length - BRACE_PAIR_LEN) === CH_CLOSE_BRACE
+    ) {
+      return jq.execRaw(
+        jsonStr,
+        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), execOptions);
+  let result = template.slice(0, firstIndex.start - BRACE_PAIR_LEN);
+  for (let i = 0; i < indices.length; i++) {
+    const index = indices[i];
+    const jqResult = jq.execRaw(
+      jsonStr,
+      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)) +
-      // Add to the result from template end index. if last template index - until the end of string, else until next start index
-      template.slice(
-        index.end + '}}'.length,
-        i + 1 === indices.length ? template.length : indices[i + 1].start - '{{'.length,
-      );
-  });
+      typeof jqResult === "string" ? jqResult : JSON.stringify(jqResult);
+    result += template.slice(
+      index.end + BRACE_PAIR_LEN,
+      i + 1 === indices.length
+        ? template.length
+        : indices[i + 1].start - BRACE_PAIR_LEN
+    );
+  }
 
   return result;
-}
+};
+
+const renderRecursively = (inputJson, template, execOptions) => {
+  if (!execOptions) execOptions = {};
+  const jsonStr = JSON.stringify(inputJson);
+  return _renderRecursively(jsonStr, template, execOptions);
+};
 
-const renderRecursively = (inputJson, template, execOptions = {}) => {
-  if (typeof template === 'string') {
-    return render(inputJson, template, execOptions);
+const _renderRecursively = (jsonStr, template, execOptions) => {
+  if (typeof template === "string") {
+    return render(jsonStr, template, execOptions);
   }
   if (Array.isArray(template)) {
-    return template.map((value) => renderRecursively(inputJson, value, execOptions));
+    const len = template.length;
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = _renderRecursively(jsonStr, template[i], execOptions);
+    }
+    return result;
   }
-  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);
-        }
+  if (typeof template === "object" && template !== null) {
+    const keys = Object.keys(template);
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const value = template[key];
 
-        const evaluatedKey = renderRecursively(inputJson, key, execOptions);
-        if (!['undefined', 'string'].includes(typeof evaluatedKey) && evaluatedKey !== null) {
+      if (SPREAD_KEYWORD_PATTERN.test(key)) {
+        const evaluatedValue = _renderRecursively(jsonStr, value, execOptions);
+        if (typeof evaluatedValue !== "object") {
           throw new Error(
-            `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(evaluatedKey)}`,
+            `Evaluated value should be an object if the key is ${key}. Original value: ${value}, evaluated to: ${JSON.stringify(
+              evaluatedValue
+            )}`
           );
         }
-        return evaluatedKey ? [[evaluatedKey, renderRecursively(inputJson, value, execOptions)]] : [];
-      }),
-    );
+        const spreadKeys = Object.keys(evaluatedValue);
+        for (let j = 0; j < spreadKeys.length; j++) {
+          result[spreadKeys[j]] = evaluatedValue[spreadKeys[j]];
+        }
+        continue;
+      }
+
+      const evaluatedKey = _renderRecursively(jsonStr, key, execOptions);
+      const keyType = typeof evaluatedKey;
+      if (
+        keyType !== "undefined" &&
+        keyType !== "string" &&
+        evaluatedKey !== null
+      ) {
+        throw new Error(
+          `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(
+            evaluatedKey
+          )}`
+        );
+      }
+      if (evaluatedKey) {
+        result[evaluatedKey] = _renderRecursively(jsonStr, value, execOptions);
+      }
+    }
+    return result;
   }
 
   return template;
-}
+};
 
 module.exports = {
-  renderRecursively
+  renderRecursively,
 };

package/lib/templateAsync.js

@@ -1,129 +1,145 @@
-const jq = require('./jq');
+const jq = require("./jq");
+const findInsideDoubleBracesIndices = require("./parse");
 
-const SPREAD_KEYWORD_PATTERN = /^\s*\{\{\s*spreadValue\(\s*\)\s*\}\}\s*$/;  // matches {{ <Keyword>() }} with white spaces where you'd expect them
+const CH_OPEN_BRACE = 123; // '{'
+const CH_CLOSE_BRACE = 125; // '}'
+const BRACE_PAIR_LEN = 2; // length of '{{' or '}}'
 
-const findInsideDoubleBracesIndices = (input) => {
-  let wrappingQuote = null;
-  let insideDoubleBracesStart = null;
-  const indices = [];
+const SPREAD_KEYWORD_PATTERN = /^\s*\{\{\s*spreadValue\(\s*\)\s*\}\}\s*$/;
 
-  for (let i = 0; i < input.length; i += 1) {
-    const char = input[i];
-
-    if (insideDoubleBracesStart && char === '\\') {
-      // If next character is escaped, skip it
-      i += 1;
-    }
-    if (insideDoubleBracesStart && (char === '"' || char === "'")) {
-      // If inside double braces and inside quotes, ignore braces
-      if (!wrappingQuote) {
-        wrappingQuote = char;
-      } else if (wrappingQuote === char) {
-        wrappingQuote = null;
-      }
-    } else if (!wrappingQuote && char === '{' && i > 0 && input[i - 1] === '{') {
-      // if opening double braces that not wrapped with quotes
-      if (insideDoubleBracesStart) {
-        throw new Error(`Found double braces in index ${i - 1} inside other one in index ${insideDoubleBracesStart - '{{'.length}`);
-      }
-      insideDoubleBracesStart = i + 1;
-      if (input[i + 1] === '{') {
-        // To overcome three "{" in a row considered as two different opening double braces
-        i += 1;
-      }
-    } else if (!wrappingQuote && char === '}' && i > 0 && input[i - 1] === '}') {
-      // if closing double braces that not wrapped with quotes
-      if (insideDoubleBracesStart) {
-        indices.push({start: insideDoubleBracesStart, end: i - 1});
-        insideDoubleBracesStart = null;
-        if (input[i + 1] === '}') {
-          // To overcome three "}" in a row considered as two different closing double braces
-          i += 1;
-        }
-      } else {
-        throw new Error(`Found closing double braces in index ${i - 1} without opening double braces`);
-      }
-    }
-  }
-
-  if (insideDoubleBracesStart) {
-    throw new Error(`Found opening double braces in index ${insideDoubleBracesStart - '{{'.length} without closing double braces`);
-  }
-
-  return indices;
-}
-
-const renderAsync =async (inputJson, template, execOptions = {}) => {
-  if (typeof template !== 'string') {
+const renderAsync = async (jsonStr, template, execOptions) => {
+  if (typeof template !== "string") {
     return null;
   }
   const indices = findInsideDoubleBracesIndices(template);
   if (!indices.length) {
-    // If no jq templates in string, return it
     return 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.execAsync(inputJson, template.slice(firstIndex.start, firstIndex.end), execOptions);
+  if (indices.length === 1) {
+    const trimmed = template.trim();
+    if (
+      trimmed.charCodeAt(0) === CH_OPEN_BRACE &&
+      trimmed.charCodeAt(1) === CH_OPEN_BRACE &&
+      trimmed.charCodeAt(trimmed.length - 1) === CH_CLOSE_BRACE &&
+      trimmed.charCodeAt(trimmed.length - BRACE_PAIR_LEN) === CH_CLOSE_BRACE
+    ) {
+      return jq.execRawAsync(
+        jsonStr,
+        template.slice(firstIndex.start, firstIndex.end),
+        execOptions
+      );
+    }
   }
 
-  let result = template.slice(0, firstIndex.start - '{{'.length); // Initiate result with string until first template start index
+  let result = template.slice(0, firstIndex.start - BRACE_PAIR_LEN);
   for (let i = 0; i < indices.length; i++) {
     const index = indices[i];
-    const jqResult = await jq.execAsync(inputJson, template.slice(index.start, index.end), execOptions);
+    const jqResult = await jq.execRawAsync(
+      jsonStr,
+      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)) +
-      // Add to the result from template end index. if last template index - until the end of string, else until next start index
-      template.slice(
-        index.end + '}}'.length,
-        i + 1 === indices.length ? template.length : indices[i + 1].start - '{{'.length,
-      );
-    }
+      typeof jqResult === "string" ? jqResult : JSON.stringify(jqResult);
+    result += template.slice(
+      index.end + BRACE_PAIR_LEN,
+      i + 1 === indices.length
+        ? template.length
+        : indices[i + 1].start - BRACE_PAIR_LEN
+    );
+  }
 
   return result;
-}
+};
+
+const renderRecursivelyAsync = async (inputJson, template, execOptions) => {
+  if (!execOptions) execOptions = {};
+  const jsonStr = JSON.stringify(inputJson);
+  return _renderRecursivelyAsync(jsonStr, template, execOptions);
+};
 
-const renderRecursivelyAsync = async(inputJson, template, execOptions = {}) => {
-  if (typeof template === 'string') {
-    return renderAsync(inputJson, template, execOptions);
+const _renderRecursivelyAsync = async (jsonStr, template, execOptions) => {
+  if (typeof template === "string") {
+    return renderAsync(jsonStr, template, execOptions);
   }
   if (Array.isArray(template)) {
-    return Promise.all(template.map((value) => renderRecursivelyAsync(inputJson, value, execOptions)));
+    const len = template.length;
+    const promises = new Array(len);
+    for (let i = 0; i < len; i++) {
+      promises[i] = _renderRecursivelyAsync(jsonStr, template[i], execOptions);
+    }
+    return Promise.all(promises);
   }
-  if (typeof template === 'object' && template !== null) {
-      const t = Object.entries(template).map(async([key, value]) => {
-
-        if (SPREAD_KEYWORD_PATTERN.test(key)) {
-          const evaluatedValue = await renderRecursivelyAsync(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 = await renderRecursivelyAsync(inputJson, key, execOptions);
-        if (typeof evaluatedKey !== 'string' && evaluatedKey != null) {
-          throw new Error(
-            `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(evaluatedKey)}`,
-          );
+  if (typeof template === "object" && template !== null) {
+    const keys = Object.keys(template);
+    const len = keys.length;
+    const promises = new Array(len);
+    for (let i = 0; i < len; i++) {
+      const key = keys[i];
+      promises[i] = _processKeyAsync(jsonStr, key, template[key], execOptions);
+    }
+    const entries = await Promise.all(promises);
+    const result = {};
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry) {
+        const pairs = entry.pairs;
+        for (let j = 0; j < pairs.length; j++) {
+          result[pairs[j][0]] = pairs[j][1];
         }
-        return evaluatedKey ? [[evaluatedKey, await renderRecursivelyAsync(inputJson, value, execOptions)]] : [];
-      });
-
-
-    return Object.fromEntries((await Promise.all(t)).flat());
+      }
+    }
+    return result;
+  }
 
+  return template;
+};
 
+const _processKeyAsync = async (jsonStr, key, value, execOptions) => {
+  if (SPREAD_KEYWORD_PATTERN.test(key)) {
+    const evaluatedValue = await _renderRecursivelyAsync(
+      jsonStr,
+      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
+        )}`
+      );
+    }
+    const spreadKeys = Object.keys(evaluatedValue);
+    const pairs = new Array(spreadKeys.length);
+    for (let i = 0; i < spreadKeys.length; i++) {
+      pairs[i] = [spreadKeys[i], evaluatedValue[spreadKeys[i]]];
+    }
+    return { pairs };
   }
 
-  return template;
-}
+  const evaluatedKey = await _renderRecursivelyAsync(jsonStr, key, execOptions);
+  if (typeof evaluatedKey !== "string" && evaluatedKey != null) {
+    throw new Error(
+      `Evaluated object key should be undefined, null or string. Original key: ${key}, evaluated to: ${JSON.stringify(
+        evaluatedKey
+      )}`
+    );
+  }
+  if (evaluatedKey) {
+    return {
+      pairs: [
+        [
+          evaluatedKey,
+          await _renderRecursivelyAsync(jsonStr, value, execOptions),
+        ],
+      ],
+    };
+  }
+  return null;
+};
 
 module.exports = {
-  renderRecursivelyAsync
+  renderRecursivelyAsync,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@port-labs/jq-node-bindings",
-  "version": "v1.1.0-dev",
+  "version": "v1.1.0-dev.1",
   "description": "Node.js bindings for JQ",
   "jq-node-bindings": "v1.1.0-dev",
   "main": "lib/index.js",
@@ -45,4 +45,3 @@
     "node": ">=6.0.0"
   }
 }
-

package/test/template-async.test.js

@@ -164,15 +164,15 @@ describe('template', () => {
         expect(await jq.renderRecursivelyAsync({}, '{{env}}')).toEqual({});
     })
     it('test throw on error', async () => {
-        expect(async () => { await jq.renderRecursivelyAsync({}, '{{foo}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{foo}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1");
         expect(async () => { await jq.renderRecursivelyAsync({}, '{{1/0}}', {throwOnError: true}) }).rejects.toThrow("number (1) and number (0) cannot be divided because the divisor is zero");
-        expect(async () => { await jq.renderRecursivelyAsync({}, '{{{}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: syntax error, unexpected end of file (Unix shell quoting issues?) at <top-level>, line 1:");
-        expect(async () => { await jq.renderRecursivelyAsync({}, '{{ {(0):1} }}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
-        expect(async () => { await jq.renderRecursivelyAsync({}, '{{if true then 1 else 0}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{{}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: syntax error, unexpected end of file");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{ {(0):1} }}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{if true then 1 else 0}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1");
         expect(async () => { await jq.renderRecursivelyAsync({}, '{{null | map(.+1)}}', {throwOnError: true}) }).rejects.toThrow("jq: error: Cannot iterate over null (null)");
         expect(async () => { await jq.renderRecursivelyAsync({foo: "bar"}, '{{.foo + 1}}', {throwOnError: true}) }).rejects.toThrow("jq: error: string (\"bar\") and number (1) cannot be added");
-        expect(async () => { await jq.renderRecursivelyAsync({}, '{{foo}}/{{bar}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
-        expect(async () => { await jq.renderRecursivelyAsync({}, '/{{foo}}/', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{foo}}/{{bar}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '/{{foo}}/', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1");
         expect(async () => { await jq.renderRecursivelyAsync({}, { "{{ spreadValue() }}": "str" }, { throwOnError: true }) })
             .rejects.toThrow('Evaluated value should be an object if the key is {{ spreadValue() }}. Original value: str, evaluated to: "str"');
         expect(async () => { await jq.renderRecursivelyAsync({}, { "{{ spreadValue() }}": "{{ \"str\" }}" }, { throwOnError: true }) })