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

package/dist/auth-sudo.js

@@ -0,0 +1,146 @@
+"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;
+});
+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.
+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}`);
+    }
+    try {
+        // 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
+            });
+        }
+        else {
+            response = await (0, node_fetch_1.default)(sparqlEndpoint, {
+                method: 'POST',
+                body: formData.toString(),
+                headers
+            });
+        }
+        return await response.json();
+    }
+    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, extraHeaders = {}, connectionOptions = {}) {
+    if (LOG_SPARQL_QUERIES) {
+        console.log(queryString);
+    }
+    return executeRawQuery(queryString, extraHeaders, connectionOptions);
+}
+exports.querySudo = querySudo;
+function updateSudo(queryString, extraHeaders = {}, connectionOptions = {}) {
+    if (LOG_SPARQL_UPDATES) {
+        console.log(queryString);
+    }
+    return executeRawQuery(queryString, extraHeaders, connectionOptions);
+}
+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;
+    }
+    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));
+}
+const defaultExport = {
+    querySudo,
+    updateSudo
+};
+exports.default = defaultExport;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@lblod/mu-auth-sudo",
-  "version": "1.0.0-beta.1",
+  "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",
-    "prepublish": "npm run build",
+    "prepare": "npm run build",
     "lint": "tslint -p tsconfig.json",
     "test": "echo \"Error: no test specified\" && exit 1",
     "release": "release-it"