@port-labs/jq-node-bindings 0.0.1

package/deps/jq/util.c

@@ -0,0 +1,462 @@
+
+#ifdef HAVE_MEMMEM
+#define _GNU_SOURCE
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stddef.h>
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#elif !defined alloca
+# ifdef __GNUC__
+#  define alloca __builtin_alloca
+# elif defined _MSC_VER
+#  include <malloc.h>
+#  define alloca _alloca
+# elif !defined HAVE_ALLOCA
+#  ifdef  __cplusplus
+extern "C"
+#  endif
+void *alloca (size_t);
+# endif
+#endif
+#ifndef WIN32
+#include <pwd.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#include <processenv.h>
+#include <shellapi.h>
+#include <wchar.h>
+#include <wtypes.h>
+#endif
+
+
+#include "util.h"
+#include "jq.h"
+#include "jv_alloc.h"
+
+#ifdef WIN32
+FILE *fopen(const char *fname, const char *mode) {
+  size_t sz = MultiByteToWideChar(CP_UTF8, 0, fname, -1, NULL, 0);
+  wchar_t *wfname = alloca(sz);
+  MultiByteToWideChar(CP_UTF8, 0, fname, -1, wfname, sz);
+
+  sz = MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0);
+  wchar_t *wmode = alloca(sz);
+  MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, sz);
+  return _wfopen(wfname, wmode);
+}
+#endif
+
+#ifndef HAVE_MKSTEMP
+int mkstemp(char *template) {
+  size_t len = strlen(template);
+  int tries=5;
+  int fd;
+
+  // mktemp() truncates template when it fails
+  char *s = alloca(len + 1);
+  assert(s != NULL);
+  strcpy(s, template);
+
+  do {
+    // Restore template
+    strcpy(template, s);
+    (void) mktemp(template);
+    fd = open(template, O_CREAT | O_EXCL | O_RDWR, 0600);
+  } while (fd == -1 && tries-- > 0);
+  return fd;
+}
+#endif
+
+jv expand_path(jv path) {
+  assert(jv_get_kind(path) == JV_KIND_STRING);
+  const char *pstr = jv_string_value(path);
+  jv ret = path;
+  if (jv_string_length_bytes(jv_copy(path)) > 1 && pstr[0] == '~' && pstr[1] == '/') {
+    jv home = get_home();
+    if (jv_is_valid(home)) {
+      ret = jv_string_fmt("%s/%s",jv_string_value(home),pstr+2);
+      jv_free(home);
+    } else {
+      jv emsg = jv_invalid_get_msg(home);
+      ret = jv_invalid_with_msg(jv_string_fmt("Could not expand %s. (%s)", pstr, jv_string_value(emsg)));
+      jv_free(emsg);
+    }
+    jv_free(path);
+  }
+  return ret;
+}
+
+jv get_home() {
+  jv ret;
+  char *home = getenv("HOME");
+  if (!home) {
+#ifndef WIN32
+    struct passwd* pwd = getpwuid(getuid());
+    if (pwd)
+      ret = jv_string(pwd->pw_dir);
+    else
+      ret = jv_invalid_with_msg(jv_string("Could not find home directory."));
+#else
+    home = getenv("USERPROFILE");
+    if (!home) {
+      char *hd = getenv("HOMEDRIVE");
+      if (!hd) hd = "";
+      home = getenv("HOMEPATH");
+      if (!home) {
+        ret = jv_invalid_with_msg(jv_string("Could not find home directory."));
+      } else {
+        ret = jv_string_fmt("%s%s",hd,home);
+      }
+    } else {
+      ret = jv_string(home);
+    }
+#endif
+  } else {
+    ret = jv_string(home);
+  }
+  return ret;
+}
+
+
+jv jq_realpath(jv path) {
+  int path_max;
+  char *buf = NULL;
+#ifdef _PC_PATH_MAX
+  path_max = pathconf(jv_string_value(path),_PC_PATH_MAX);
+#else
+  path_max = PATH_MAX;
+#endif
+  if (path_max > 0) {
+     buf = malloc(sizeof(char) * path_max);
+  }
+#ifdef WIN32
+  char *tmp = _fullpath(buf, jv_string_value(path), path_max);
+#else
+  char *tmp = realpath(jv_string_value(path), buf);
+#endif
+  if (tmp == NULL) {
+    free(buf);
+    return path;
+  }
+  jv_free(path);
+  path = jv_string(tmp);
+  free(tmp);
+  return path;
+}
+
+const void *_jq_memmem(const void *haystack, size_t haystacklen,
+                       const void *needle, size_t needlelen) {
+#ifdef HAVE_MEMMEM
+  return (const void*)memmem(haystack, haystacklen, needle, needlelen);
+#else
+  const char *h = haystack;
+  const char *n = needle;
+  size_t hi, hi2, ni;
+
+  if (haystacklen < needlelen || haystacklen == 0)
+    return NULL;
+  for (hi = 0; hi < (haystacklen - needlelen + 1); hi++) {
+    for (ni = 0, hi2 = hi; ni < needlelen; ni++, hi2++) {
+      if (h[hi2] != n[ni])
+        goto not_this;
+    }
+
+    return &h[hi];
+
+not_this:
+    continue;
+  }
+  return NULL;
+#endif /* !HAVE_MEMMEM */
+}
+
+struct jq_util_input_state {
+  jq_util_msg_cb err_cb;
+  void *err_cb_data;
+  jv_parser *parser;
+  FILE* current_input;
+  char **files;
+  int nfiles;
+  int curr_file;
+  int failures;
+  jv slurped;
+  char buf[4096];
+  size_t buf_valid_len;
+  jv current_filename;
+  size_t current_line;
+};
+
+static void fprinter(void *data, const char *fname) {
+  fprintf((FILE *)data, "jq: error: Could not open file %s: %s\n", fname, strerror(errno));
+}
+
+// If parser == NULL -> RAW
+jq_util_input_state *jq_util_input_init(jq_util_msg_cb err_cb, void *err_cb_data) {
+  if (err_cb == NULL) {
+    err_cb = fprinter;
+    err_cb_data = stderr;
+  }
+  jq_util_input_state *new_state = jv_mem_alloc(sizeof(*new_state));
+  memset(new_state, 0, sizeof(*new_state));
+  new_state->err_cb = err_cb;
+  new_state->err_cb_data = err_cb_data;
+  new_state->parser = NULL;
+  new_state->current_input = NULL;
+  new_state->files = NULL;
+  new_state->nfiles = 0;
+  new_state->curr_file = 0;
+  new_state->slurped = jv_invalid();
+  new_state->buf[0] = 0;
+  new_state->buf_valid_len = 0;
+  new_state->current_filename = jv_invalid();
+  new_state->current_line = 0;
+
+  return new_state;
+}
+
+void jq_util_input_set_parser(jq_util_input_state *state, jv_parser *parser, int slurp) {
+  assert(!jv_is_valid(state->slurped));
+  state->parser = parser;
+
+  if (parser == NULL && slurp)
+    state->slurped = jv_string("");
+  else if (slurp)
+    state->slurped = jv_array();
+  else
+    state->slurped = jv_invalid();
+}
+
+void jq_util_input_free(jq_util_input_state **state) {
+  jq_util_input_state *old_state = *state;
+  *state = NULL;
+  if (old_state == NULL)
+    return;
+
+  if (old_state->parser != NULL)
+    jv_parser_free(old_state->parser);
+  for (int i = 0; i < old_state->nfiles; i++)
+    free(old_state->files[i]);
+  free(old_state->files);
+  jv_free(old_state->slurped);
+  jv_free(old_state->current_filename);
+  jv_mem_free(old_state);
+}
+
+void jq_util_input_add_input(jq_util_input_state *state, const char *fname) {
+  state->files = jv_mem_realloc(state->files, (state->nfiles + 1) * sizeof(state->files[0]));
+  state->files[state->nfiles++] = jv_mem_strdup(fname);
+}
+
+int jq_util_input_errors(jq_util_input_state *state) {
+  return state->failures;
+}
+
+static const char *next_file(jq_util_input_state *state) {
+  if (state->curr_file < state->nfiles)
+    return state->files[state->curr_file++];
+  return NULL;
+}
+
+static int jq_util_input_read_more(jq_util_input_state *state) {
+  if (!state->current_input || feof(state->current_input) || ferror(state->current_input)) {
+    if (state->current_input && ferror(state->current_input)) {
+      // System-level input error on the stream. It will be closed (below).
+      // TODO: report it. Can't use 'state->err_cb()' as it is hard-coded for
+      //       'open' related problems.
+      fprintf(stderr,"Input error: %s\n", strerror(errno));
+    }
+    if (state->current_input) {
+      if (state->current_input == stdin) {
+        clearerr(stdin); // perhaps we can read again; anyways, we don't fclose(stdin)
+      } else {
+        fclose(state->current_input);
+      }
+      state->current_input = NULL;
+      jv_free(state->current_filename);
+      state->current_filename = jv_invalid();
+      state->current_line = 0 ;
+    }
+    const char *f = next_file(state);
+    if (f != NULL) {
+      if (!strcmp(f, "-")) {
+        state->current_input = stdin;
+        state->current_filename = jv_string("<stdin>");
+      } else {
+        state->current_input = fopen(f, "r");
+        state->current_filename = jv_string(f);
+        if (!state->current_input) {
+          state->err_cb(state->err_cb_data, f);
+          state->failures++;
+        }
+      }
+      state->current_line = 0;
+    }
+  }
+
+  state->buf[0] = 0;
+  state->buf_valid_len = 0;
+  if (state->current_input) {
+    char *res;
+    memset(state->buf, 0, sizeof(state->buf));
+
+    while (!(res = fgets(state->buf, sizeof(state->buf), state->current_input)) &&
+           ferror(state->current_input) && errno == EINTR)
+      clearerr(state->current_input);
+    if (res == NULL) {
+      state->buf[0] = 0;
+      if (ferror(state->current_input))
+        state->failures++;
+    } else {
+      const char *p = memchr(state->buf, '\n', sizeof(state->buf));
+
+      if (p != NULL)
+        state->current_line++;
+
+      if (p == NULL && state->parser != NULL) {
+        /*
+         * There should be no NULs in JSON texts (but JSON text
+         * sequences are another story).
+         */
+        state->buf_valid_len = strlen(state->buf);
+      } else if (p == NULL && feof(state->current_input)) {
+        size_t i;
+
+        /*
+         * XXX We can't know how many bytes we've read!
+         *
+         * We can't use getline() because there need not be any newlines
+         * in the input.  The only entirely correct choices are: use
+         * fgetc() or fread().  Using fread() will complicate buffer
+         * management here.
+         *
+         * For now we guess how much fgets() read.
+         */
+        for (p = state->buf, i = 0; i < sizeof(state->buf); i++) {
+          if (state->buf[i] != '\0')
+            p = &state->buf[i];
+        }
+        state->buf_valid_len = p - state->buf + 1;
+      } else if (p == NULL) {
+        state->buf_valid_len = sizeof(state->buf) - 1;
+      } else {
+        state->buf_valid_len = (p - state->buf) + 1;
+      }
+    }
+  }
+  return state->curr_file == state->nfiles &&
+      (!state->current_input || feof(state->current_input) || ferror(state->current_input));
+}
+
+jv jq_util_input_next_input_cb(jq_state *jq, void *data) {
+  return jq_util_input_next_input((jq_util_input_state *)data);
+}
+
+// Return the current_filename:current_line
+jv jq_util_input_get_position(jq_state *jq) {
+  jq_input_cb cb = NULL;
+  void *cb_data = NULL;
+  jq_get_input_cb(jq, &cb, &cb_data);
+  assert(cb == jq_util_input_next_input_cb);
+  if (cb != jq_util_input_next_input_cb)
+    return jv_invalid_with_msg(jv_string("Invalid jq_util_input API usage"));
+  jq_util_input_state *s = (jq_util_input_state *)cb_data;
+
+  // We can't assert that current_filename is a string because if
+  // the error was a JSON parser error then we may not have set
+  // current_filename yet.
+  if (jv_get_kind(s->current_filename) != JV_KIND_STRING)
+    return jv_string("<unknown>");
+
+  jv v = jv_string_fmt("%s:%lu", jv_string_value(s->current_filename), (unsigned long)s->current_line);
+  return v;
+}
+
+jv jq_util_input_get_current_filename(jq_state* jq) {
+  jq_input_cb cb=NULL;
+  void *cb_data=NULL;
+  jq_get_input_cb(jq, &cb, &cb_data);
+  if (cb != jq_util_input_next_input_cb)
+    return jv_invalid_with_msg(jv_string("Unknown input filename"));
+  jq_util_input_state *s = (jq_util_input_state *)cb_data;
+  jv v = jv_copy(s->current_filename);
+  return v;
+}
+
+jv jq_util_input_get_current_line(jq_state* jq) {
+  jq_input_cb cb=NULL;
+  void *cb_data=NULL;
+  jq_get_input_cb(jq, &cb, &cb_data);
+  if (cb != jq_util_input_next_input_cb)
+    return jv_invalid_with_msg(jv_string("Unknown input line number"));
+  jq_util_input_state *s = (jq_util_input_state *)cb_data;
+  jv v = jv_number(s->current_line);
+  return v;
+}
+
+
+// Blocks to read one more input from stdin and/or given files
+// When slurping, it returns just one value
+jv jq_util_input_next_input(jq_util_input_state *state) {
+  int is_last = 0;
+  jv value = jv_invalid(); // need more input
+  do {
+    if (state->parser == NULL) {
+      // Raw input
+      is_last = jq_util_input_read_more(state);
+      if (state->buf_valid_len == 0)
+        continue;
+      if (jv_is_valid(state->slurped)) {
+        // Slurped raw input
+        state->slurped = jv_string_concat(state->slurped, jv_string_sized(state->buf, state->buf_valid_len));
+      } else {
+        if (!jv_is_valid(value))
+          value = jv_string("");
+        if (state->buf[state->buf_valid_len-1] == '\n') {
+          // whole line
+          state->buf[state->buf_valid_len-1] = 0;
+          return jv_string_concat(value, jv_string_sized(state->buf, state->buf_valid_len-1));
+        }
+        value = jv_string_concat(value, jv_string_sized(state->buf, state->buf_valid_len));
+        state->buf[0] = '\0';
+        state->buf_valid_len = 0;
+      }
+    } else {
+      if (jv_parser_remaining(state->parser) == 0) {
+        is_last = jq_util_input_read_more(state);
+        if (is_last && state->buf_valid_len == 0) {
+          value = jv_invalid();
+          break;
+        }
+        jv_parser_set_buf(state->parser, state->buf, state->buf_valid_len, !is_last);
+      }
+      value = jv_parser_next(state->parser);
+      if (jv_is_valid(state->slurped)) {
+        if (jv_is_valid(value)) {
+          state->slurped = jv_array_append(state->slurped, value);
+          value = jv_invalid();
+        } else if (jv_invalid_has_msg(jv_copy(value)))
+          return value; // Not slurped parsed input
+      } else if (jv_is_valid(value) || jv_invalid_has_msg(jv_copy(value))) {
+        return value;
+      }
+    }
+  } while (!is_last);
+
+  if (jv_is_valid(state->slurped)) {
+    value = state->slurped;
+    state->slurped = jv_invalid();
+  }
+  return value;
+}

package/deps/jq/util.h

@@ -0,0 +1,64 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#ifdef WIN32
+/* For WriteFile() below */
+#include <windows.h>
+#include <io.h>
+#include <processenv.h>
+#include <shellapi.h>
+#include <wchar.h>
+#include <wtypes.h>
+#endif
+
+#include "jv.h"
+
+#ifndef HAVE_MKSTEMP
+int mkstemp(char *template);
+#endif
+
+jv expand_path(jv);
+jv get_home(void);
+jv jq_realpath(jv);
+
+/*
+ * The Windows CRT and console are something else.  In order for the
+ * console to get UTF-8 written to it correctly we have to bypass stdio
+ * completely.  No amount of fflush()ing helps.  If the first byte of a
+ * buffer being written with fwrite() is non-ASCII UTF-8 then the
+ * console misinterprets the byte sequence.  But one must not
+ * WriteFile() if stdout is a file!1!!
+ *
+ * We carry knowledge of whether the FILE * is a tty everywhere we
+ * output to it just so we can write with WriteFile() if stdout is a
+ * console on WIN32.
+ */
+
+static void priv_fwrite(const char *s, size_t len, FILE *fout, int is_tty) {
+#ifdef WIN32
+  if (is_tty)
+    WriteFile((HANDLE)_get_osfhandle(fileno(fout)), s, len, NULL, NULL);
+  else
+    fwrite(s, 1, len, fout);
+#else
+  fwrite(s, 1, len, fout);
+#endif
+}
+
+const void *_jq_memmem(const void *haystack, size_t haystacklen,
+                       const void *needle, size_t needlelen);
+
+#ifndef MIN
+#define MIN(a,b) \
+  ({ __typeof__ (a) _a = (a); \
+   __typeof__ (b) _b = (b); \
+   _a < _b ? _a : _b; })
+#endif
+#ifndef MAX
+#define MAX(a,b) \
+  ({ __typeof__ (a) _a = (a); \
+   __typeof__ (b) _b = (b); \
+   _a > _b ? _a : _b; })
+#endif
+
+#endif /* UTIL_H */

package/deps/jq.gyp

@@ -0,0 +1,35 @@
+{
+    'targets': [
+        {
+            "target_name": "jq",
+            "type": "none",
+            "actions": [
+                {
+                    "action_name": "configure",
+                    "inputs": [],
+                    "action": [
+                        "node", "../util/configure"
+                    ],
+                    "conditions": [
+                        [
+                            'OS=="mac"',
+                            {
+                                'outputs': [
+                                    'deps/libjq/src/libjq.dylib',
+                                    'deps/libjq/src/libjq.1.dylib'
+                                ]
+                            },
+                            {
+                                'outputs': [
+                                    'deps/jq/src/libjq.so',
+                                    'deps/jq/src/libjq.so.1',
+                                    'deps/jq/src/libjq.a'
+                                ],
+                            }
+                        ]
+                    ]
+                }
+            ],
+        }
+    ]
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+declare module 'jq-node-bindings' {
+    export function exec(json: object, input: string): object | Array<any> | string | number | boolean | null;
+}

package/jest.config.js

@@ -0,0 +1,10 @@
+const config = {
+	verbose: true,
+	testMatch: ['**/?(*.)+(spec|test).[jt]s'],
+	reporters: [
+		'default',
+		['jest-junit', {outputDirectory: 'reports', outputName: 'jest-port-api.xml'}]
+	],
+	bail: true,
+};
+module.exports = config;

package/lib/index.js

@@ -0,0 +1,14 @@
+const nativeJq = require('bindings')('jq-node-bindings')
+
+module.exports = {
+  exec: (object, filter) => {
+    try {
+      const data =  nativeJq.exec(JSON.stringify(object), filter)
+
+      return data?.value;
+    } catch (err) {
+      return null
+    }
+  }
+};
+

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@port-labs/jq-node-bindings",
+  "version": "v0.0.1",
+  "description": "Node.js bindings for JQ",
+  "jq-node-bindings": "0.0.1",
+  "main": "lib/index.js",
+  "scripts": {
+    "configure": "node-gyp configure",
+    "build": "node-gyp build",
+    "install": "node-gyp rebuild",
+    "prepack": "npm run test",
+    "test": "jest"
+  },
+  "keywords": [
+    "jq",
+    "binding"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:port-labs/jq-node-bindings.git"
+  },
+  "contributors": [
+    {
+      "name": "Daniel Sinai",
+      "email": "daniel.sinai.main@gmail.com"
+    }
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "bluebird": "^3.5.3",
+    "jest": "^29.0.5",
+    "jest-junit": "^15.0.0",
+    "jsdoc": "^3.4.0",
+    "jshint": "^2.10.1",
+    "mocha": "^10.2.0",
+    "node-gyp": "^9.3.1",
+    "prettier": "^2.5.1",
+    "toolkit-jsdoc": "^1.0.0"
+  },
+  "dependencies": {
+    "bindings": "^1.3.1",
+    "jqts": "^0.0.8",
+    "nan": "^2.17.0"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  }
+}

package/reports/jest-port-api.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="jest tests" tests="15" failures="0" errors="0" time="0.356">
+  <testsuite name="jq" errors="0" failures="0" skipped="0" timestamp="2023-02-15T20:09:42" time="0.316" tests="15">
+    <testcase classname="jq should break" name="jq should break" time="0.003">
+    </testcase>
+    <testcase classname="jq should break for invalid input" name="jq should break for invalid input" time="0.002">
+    </testcase>
+    <testcase classname="jq should break for invalid input" name="jq should break for invalid input" time="0.002">
+    </testcase>
+    <testcase classname="jq should break for invalid input" name="jq should break for invalid input" time="0.001">
+    </testcase>
+    <testcase classname="jq string should work" name="jq string should work" time="0">
+    </testcase>
+    <testcase classname="jq number should work" name="jq number should work" time="0.001">
+    </testcase>
+    <testcase classname="jq should return null" name="jq should return null" time="0.002">
+    </testcase>
+    <testcase classname="jq should return array with object" name="jq should return array with object" time="0">
+    </testcase>
+    <testcase classname="jq should return an item of an array" name="jq should return an item of an array" time="0.002">
+    </testcase>
+    <testcase classname="jq should return array with objects" name="jq should return array with objects" time="0">
+    </testcase>
+    <testcase classname="jq should return boolean" name="jq should return boolean" time="0.001">
+    </testcase>
+    <testcase classname="jq should return object" name="jq should return object" time="0">
+    </testcase>
+    <testcase classname="jq should return recursed obj" name="jq should return recursed obj" time="0.001">
+    </testcase>
+    <testcase classname="jq should return recursed obj" name="jq should return recursed obj" time="0">
+    </testcase>
+    <testcase classname="jq should return null on invalid json" name="jq should return null on invalid json" time="0">
+    </testcase>
+  </testsuite>
+</testsuites>