@lblod/mu-auth-sudo 0.6.0 → 1.0.0-beta.2

package/README.md

@@ -2,12 +2,12 @@
 NPM package for a SPARQL client for mu.semte.ch that overrules access rights in queries through a mu-auth-sudo header.
 
 ## Usage
-```
+```bash
 npm install @lblod/mu-auth-sudo
 ```
 
 Include the following in your code
-```
+```js
 import { querySudo as query, updateSudo as update } from '@lblod/mu-auth-sudo';
 
 
@@ -26,9 +26,20 @@ await update(updateString, extraHeaders);
 
 // With custom connection options (this should be exceptional, make sure you know what you're doing)
 
-const connectionOptions = { sparqlEndpoint: 'http://the.custom.endpoint/sparql', mayRetry: true };
+const connectionOptions = { sparqlEndpoint: 'http://the.custom.endpoint/sparql', mayRetry: true,  };
+
+await update(updateString, extraHeaders, connectionOptions);
+
+// Authentication via digest or basic auth
+const connectionOptions = { 
+  sparqlEndpoint: 'http://the.custom.endpoint/sparql', 
+  authUser: "dba",
+  authPassword: "mypass",
+  authType: "digest"
+};
 
 await update(updateString, extraHeaders, connectionOptions);
+
 ```
 
 ## Logging

package/dist/auth-sudo.js

@@ -1,187 +1,146 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-exports.updateSudo = exports.querySudo = undefined;
-
-var _expressHttpContext = require('express-http-context');
-
-var _expressHttpContext2 = _interopRequireDefault(_expressHttpContext);
-
-var _sparqlClient = require('sparql-client-2');
-
-var _envVar = require('env-var');
-
-var _envVar2 = _interopRequireDefault(_envVar);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var LOG_SPARQL_QUERIES = process.env.LOG_SPARQL_QUERIES != undefined ? _envVar2.default.get('LOG_SPARQL_QUERIES').asBool() : _envVar2.default.get('LOG_SPARQL_ALL').asBool();
-var LOG_SPARQL_UPDATES = process.env.LOG_SPARQL_UPDATES != undefined ? _envVar2.default.get('LOG_SPARQL_UPDATES').asBool() : _envVar2.default.get('LOG_SPARQL_ALL').asBool();
-var DEBUG_AUTH_HEADERS = _envVar2.default.get('DEBUG_AUTH_HEADERS').asBool();
-
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSudo = exports.querySudo = void 0;
+const express_http_context_1 = __importDefault(require("express-http-context"));
+const env_var_1 = __importDefault(require("env-var"));
+const node_fetch_1 = __importStar(require("node-fetch"));
+const digest_fetch_1 = __importDefault(require("digest-fetch"));
+const SPARQL_ENDPOINT = env_var_1.default.get('MU_SPARQL_ENDPOINT').required().asString();
+const LOG_SPARQL_ALL = env_var_1.default.get('LOG_SPARQL_ALL').required().asString();
+const LOG_SPARQL_QUERIES = env_var_1.default.get('LOG_SPARQL_QUERIES').default(LOG_SPARQL_ALL).asBool();
+const LOG_SPARQL_UPDATES = env_var_1.default.get('LOG_SPARQL_UPDATES').default(LOG_SPARQL_ALL).asBool();
+const DEBUG_AUTH_HEADERS = env_var_1.default.get('DEBUG_AUTH_HEADERS').required().asBool();
 // The following configuration options are considered optional, but may be overriden as a temporary workaround for issues. Thus, a last resort.
-var RETRY = _envVar2.default.get('SUDO_QUERY_RETRY').default('false').asBool();
-var RETRY_MAX_ATTEMPTS = _envVar2.default.get('SUDO_QUERY_RETRY_MAX_ATTEMPTS').default('5').asInt();
-var RETRY_FOR_HTTP_STATUS_CODES = _envVar2.default.get('SUDO_QUERY_RETRY_FOR_HTTP_STATUS_CODES').default('').asArray();
-var RETRY_FOR_CONNECTION_ERRORS = _envVar2.default.get('SUDO_QUERY_RETRY_FOR_CONNECTION_ERRORS').default('ECONNRESET,ETIMEDOUT,EAI_AGAIN').asArray();
-var RETRY_TIMEOUT_INCREMENT_FACTOR = _envVar2.default.get('SUDO_QUERY_RETRY_TIMEOUT_INCREMENT_FACTOR').default('0.3').asFloat();
-
-function sudoSparqlClient() {
-  var extraHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var connectionOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-
-  var sparqlEndpoint = process.env.MU_SPARQL_ENDPOINT;
-
-  if (connectionOptions) {
-    sparqlEndpoint = connectionOptions.sparqlEndpoint || sparqlEndpoint;
-  }
-
-  var options = {
-    requestDefaults: {
-      headers: {
-        'mu-auth-sudo': 'true'
-      }
+const RETRY = env_var_1.default.get('SUDO_QUERY_RETRY').default('false').asBool();
+const RETRY_MAX_ATTEMPTS = env_var_1.default.get('SUDO_QUERY_RETRY_MAX_ATTEMPTS').default('5').asInt();
+const RETRY_FOR_HTTP_STATUS_CODES = env_var_1.default.get('SUDO_QUERY_RETRY_FOR_HTTP_STATUS_CODES').default('').asArray();
+const RETRY_FOR_CONNECTION_ERRORS = env_var_1.default.get('SUDO_QUERY_RETRY_FOR_CONNECTION_ERRORS').default('ECONNRESET,ETIMEDOUT,EAI_AGAIN').asArray();
+const RETRY_TIMEOUT_INCREMENT_FACTOR = env_var_1.default.get('SUDO_QUERY_RETRY_TIMEOUT_INCREMENT_FACTOR').default('0.3').asFloat();
+function defaultHeaders() {
+    const headers = new node_fetch_1.Headers();
+    headers.set('content-type', 'application/x-www-form-urlencoded');
+    headers.set('mu-auth-sudo', 'true');
+    headers.set('Accept', 'application/sparql-results+json');
+    if (express_http_context_1.default.get('request')) {
+        headers.set('mu-session-id', express_http_context_1.default.get('request').get('mu-session-id'));
+        headers.set('mu-call-id', express_http_context_1.default.get('request').get('mu-call-id'));
+    }
+    return headers;
+}
+async function executeRawQuery(queryString, extraHeaders = {}, connectionOptions = {}, attempt = 0) {
+    const sparqlEndpoint = connectionOptions.sparqlEndpoint ?? SPARQL_ENDPOINT;
+    const headers = defaultHeaders();
+    for (const key of Object.keys(extraHeaders)) {
+        headers.append(key, extraHeaders[key]);
+    }
+    if (DEBUG_AUTH_HEADERS) {
+        const stringifiedHeaders = Array.from(headers.entries())
+            .filter(([key, value]) => key.startsWith('mu-'))
+            .map(([key, value]) => `${key}: ${value}`)
+            .join("\n");
+        console.log(`Headers set on SPARQL client: ${stringifiedHeaders}`);
     }
-  };
-
-  if (_expressHttpContext2.default.get('request')) {
-    options.requestDefaults.headers['mu-session-id'] = _expressHttpContext2.default.get('request').get('mu-session-id');
-    options.requestDefaults.headers['mu-call-id'] = _expressHttpContext2.default.get('request').get('mu-call-id');
-  }
-
-  if (extraHeaders) {
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
-
     try {
-      for (var _iterator = Object.keys(extraHeaders)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var key = _step.value;
-
-        options.requestDefaults.headers[key] = extraHeaders[key];
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return) {
-          _iterator.return();
+        // note that URLSearchParams is used because it correctly encodes for form-urlencoded
+        const formData = new URLSearchParams();
+        formData.set("query", queryString);
+        headers.append('Content-Length', formData.toString().length.toString());
+        let response;
+        if (connectionOptions.authUser && connectionOptions.authPassword) {
+            const client = new digest_fetch_1.default(connectionOptions.authUser, connectionOptions.authPassword, { basic: connectionOptions.authType === 'basic' });
+            response = await client.fetch(sparqlEndpoint, {
+                method: 'POST',
+                body: formData.toString(),
+                headers
+            });
         }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
+        else {
+            response = await (0, node_fetch_1.default)(sparqlEndpoint, {
+                method: 'POST',
+                body: formData.toString(),
+                headers
+            });
         }
-      }
+        return await response.json();
     }
-  }
-
-  if (DEBUG_AUTH_HEADERS) {
-    console.log('Headers set on SPARQL client: ' + JSON.stringify(options));
-  }
-
-  return new _sparqlClient.SparqlClient(sparqlEndpoint, options);
-}
-
-async function executeRawQuery(queryString) {
-  var extraHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var attempt = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-
-
-  if (LOG_SPARQL_QUERIES) {
-    console.log(queryString);
-  }
-
-  try {
-
-    var response = await sudoSparqlClient(extraHeaders, connectionOptions).query(queryString).executeRaw();
-    return maybeParseJSON(response.body);
-  } catch (ex) {
-
-    if (mayRetry(ex, attempt, connectionOptions)) {
-
-      attempt += 1;
-
-      var sleepTime = nextAttemptTimeout(attempt);
-      console.log('Sleeping ' + sleepTime + ' ms before next attempt');
-      await new Promise(function (r) {
-        return setTimeout(r, sleepTime);
-      });
-
-      return await executeRawQuery(queryString, extraHeaders, connectionOptions, attempt);
-    } else {
-      console.log('Failed Query:\n                  ' + queryString);
-      throw ex;
+    catch (ex) {
+        if (mayRetry(ex, attempt, connectionOptions)) {
+            attempt += 1;
+            const sleepTime = nextAttemptTimeout(attempt);
+            console.log(`Sleeping ${sleepTime} ms before next attempt`);
+            await new Promise(r => setTimeout(r, sleepTime));
+            return await executeRawQuery(queryString, extraHeaders, connectionOptions, attempt);
+        }
+        else {
+            console.log(`Failed Query:
+                  ${queryString}`);
+            throw ex;
+        }
     }
-  }
 }
-
-function querySudo(queryString) {
-  var extraHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-  if (LOG_SPARQL_QUERIES) {
-    console.log(queryString);
-  }
-  return executeRawQuery(queryString, extraHeaders, connectionOptions);
-}
-
-function updateSudo(queryString) {
-  var extraHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-  if (LOG_SPARQL_UPDATES) {
-    console.log(queryString);
-  }
-  return executeRawQuery(queryString, extraHeaders, connectionOptions);
+function querySudo(queryString, extraHeaders = {}, connectionOptions = {}) {
+    if (LOG_SPARQL_QUERIES) {
+        console.log(queryString);
+    }
+    return executeRawQuery(queryString, extraHeaders, connectionOptions);
 }
-
-function maybeParseJSON(body) {
-  // Catch invalid JSON
-  try {
-    return JSON.parse(body);
-  } catch (ex) {
-    return null;
-  }
+exports.querySudo = querySudo;
+function updateSudo(queryString, extraHeaders = {}, connectionOptions = {}) {
+    if (LOG_SPARQL_UPDATES) {
+        console.log(queryString);
+    }
+    return executeRawQuery(queryString, extraHeaders, connectionOptions);
 }
-
-function mayRetry(error, attempt) {
-  var connectionOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-
-  console.log('Checking retry allowed for error: ' + error + ' and attempt: ' + attempt);
-
-  var mayRetry = false;
-
-  if (!(RETRY || connectionOptions.mayRetry)) {
-    mayRetry = false;
-  } else if (attempt < RETRY_MAX_ATTEMPTS) {
-    if (error.code && RETRY_FOR_CONNECTION_ERRORS.includes(error.code)) {
-      mayRetry = true;
-    } else if (error.httpStatus && RETRY_FOR_HTTP_STATUS_CODES.includes('' + error.httpStatus)) {
-      mayRetry = true;
+exports.updateSudo = updateSudo;
+function mayRetry(error, attempt, connectionOptions = {}) {
+    console.log(`Checking retry allowed for error: ${error} and attempt: ${attempt}`);
+    let mayRetry = false;
+    if (!(RETRY || connectionOptions.mayRetry)) {
+        mayRetry = false;
     }
-  }
-
-  console.log('Retry allowed? ' + mayRetry);
-
-  return mayRetry;
+    else if (attempt < RETRY_MAX_ATTEMPTS) {
+        if (error.code && RETRY_FOR_CONNECTION_ERRORS.includes(error.code)) {
+            mayRetry = true;
+        }
+        else if (error.httpStatus && RETRY_FOR_HTTP_STATUS_CODES.includes(`${error.httpStatus}`)) {
+            mayRetry = true;
+        }
+    }
+    console.log(`Retry allowed? ${mayRetry}`);
+    return mayRetry;
 }
-
 function nextAttemptTimeout(attempt) {
-  //expected to be milliseconds
-  return Math.round(Math.exp(RETRY_TIMEOUT_INCREMENT_FACTOR * attempt + 10));
+    // expected to be milliseconds
+    return Math.round(Math.exp(RETRY_TIMEOUT_INCREMENT_FACTOR * attempt + 10));
 }
-
-var _exports = {
-  querySudo: querySudo,
-  updateSudo: updateSudo
+const defaultExport = {
+    querySudo,
+    updateSudo
 };
-
-exports.default = _exports;
-exports.querySudo = querySudo;
-exports.updateSudo = updateSudo;
+exports.default = defaultExport;

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@lblod/mu-auth-sudo",
-  "version": "0.6.0",
+  "version": "1.0.0-beta.2",
   "description": "this package provides an alternative sparql client for the mu-javascript-template that has sudo rights.",
   "main": "dist/auth-sudo.js",
   "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "lint": "tslint -p tsconfig.json",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepare": "rm -rf dist && babel src --out-dir dist/",
-    "prepublish": "rm -rf dist && babel src --out-dir dist/"
+    "release": "release-it"
   },
   "repository": {
     "type": "git",
@@ -22,24 +24,28 @@
   "bugs": {
     "url": "https://github.com/lblod/mu-auth-sudo/issues"
   },
-  "babel": {
-    "presets": [
-      "es2015"
-    ],
-    "plugins": [
-      "add-module-exports"
-    ]
-  },
   "homepage": "https://github.com/lblod/mu-auth-sudo#readme",
   "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-plugin-add-module-exports": "^1.0.4",
-    "babel-preset-env": "^1.7.0",
-    "babel-preset-es2015": "^6.24.1",
-    "babel-register": "^6.26.0"
+    "@types/node-fetch": "^2.6.2",
+    "express-http-context": "^1.2.4",
+    "prettier": "^2.7.1",
+    "release-it": "^15.5.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.8.4"
   },
   "dependencies": {
+    "digest-fetch": "^1.3.0",
     "env-var": "^7.0.1",
-    "sparql-client-2": "https://github.com/erikap/node-sparql-client.git"
-  }
+    "node-fetch": "^2.6.7"
+  },
+  "peerDependencies": {
+    "express-http-context": "~1.2.4"
+  },
+  "volta": {
+    "node": "14.20.1"
+  },
+  "files": [
+    "dist/**/*"
+  ]
 }