moeralib 0.15.0

package/lib/node/caller.js

@@ -0,0 +1,267 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Caller = exports.moeraRoot = exports.MoeraCallError = exports.MoeraNodeConnectionError = exports.MoeraNodeApiError = exports.MoeraNodeError = void 0;
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const validate_1 = require("./validate");
+const util_1 = require("../util");
+const schema_1 = require("../schema");
+class MoeraNodeError extends Error {
+    constructor(name, message) {
+        super(name + ": Node error: " + message);
+    }
+}
+exports.MoeraNodeError = MoeraNodeError;
+class MoeraNodeApiError extends MoeraNodeError {
+    constructor(name, result) {
+        super(name, result.message);
+        this.errorCode = result.errorCode;
+    }
+}
+exports.MoeraNodeApiError = MoeraNodeApiError;
+class MoeraNodeConnectionError extends Error {
+    constructor(message) {
+        super("Node connection error: " + message);
+    }
+}
+exports.MoeraNodeConnectionError = MoeraNodeConnectionError;
+class MoeraCallError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.MoeraCallError = MoeraCallError;
+function encodeBody(decoded, format) {
+    var _a;
+    if (decoded == null) {
+        return null;
+    }
+    if (format === "application") {
+        return (_a = decoded.text) !== null && _a !== void 0 ? _a : null;
+    }
+    return JSON.stringify(decoded);
+}
+function encodeBodies(data) {
+    if (Array.isArray(data)) {
+        return data.map(item => encodeBodies(item));
+    }
+    const encoded = (0, lodash_clonedeep_1.default)(data);
+    if (data.body != null) {
+        encoded.body = encodeBody(data.body, data.bodyFormat);
+    }
+    if (data.bodyPreview != null) {
+        encoded.body = encodeBody(data.bodyPreview, data.bodyFormat);
+    }
+    if (data.bodySrc != null) {
+        encoded.bodySrc = encodeBody(data.bodySrc, data.bodySrcFormat);
+    }
+    return encoded;
+}
+function decodeBody(name, encoded, format) {
+    if (format === "application") {
+        return { text: encoded };
+    }
+    let body;
+    try {
+        body = JSON.parse(encoded);
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            throw new MoeraNodeError(name, "Invalid body encoding: " + e.message);
+        }
+        throw e;
+    }
+    const { valid, errors } = (0, validate_1.validateSchema)("Body", body);
+    if (!valid) {
+        throw new MoeraNodeError(name, "Invalid body: " + (0, schema_1.formatSchemaErrors)(errors));
+    }
+    return body;
+}
+function decodeBodies(name, data) {
+    if (Array.isArray(data)) {
+        return data.map(item => decodeBodies(name, item));
+    }
+    const decoded = (0, lodash_clonedeep_1.default)(data);
+    if (data.stories != null) {
+        decoded.stories = data.stories.map((item) => decodeBodies(name, item));
+    }
+    if (data.comments != null) {
+        decoded.comments = data.comments.map((item) => decodeBodies(name, item));
+    }
+    if (data.comment != null) {
+        decoded.comment = decodeBodies(name, data.comment);
+    }
+    if (data.posting != null) {
+        decoded.posting = decodeBodies(name, data.posting);
+    }
+    if (data.body != null) {
+        decoded.body = decodeBody(name, data.body, data.bodyFormat);
+    }
+    if (data.bodyPreview != null) {
+        decoded.bodyPreview = decodeBody(name, data.bodyPreview, data.bodyFormat);
+    }
+    if (data.bodySrc != null) {
+        decoded.bodySrc = decodeBody(name, data.bodySrc, data.bodySrcFormat);
+    }
+    return decoded;
+}
+function moeraRoot(url) {
+    if (!url.startsWith("http:") && !url.startsWith("https:")) {
+        url = "https://" + url;
+    }
+    if (url.endsWith("/")) {
+        url = url.slice(0, -1);
+    }
+    if (url.endsWith("/api")) {
+        url = url.slice(0, -4);
+    }
+    if (!url.endsWith("/moera")) {
+        url += "/moera";
+    }
+    return url;
+}
+exports.moeraRoot = moeraRoot;
+class Caller {
+    constructor() {
+        this.root = null;
+        this._rootSecret = null;
+        this._token = null;
+        this._carte = null;
+        this._carteSource = null;
+        this._authMethod = "none";
+    }
+    nodeUrl(url) {
+        this.root = moeraRoot(url);
+    }
+    rootSecret(secret) {
+        this._rootSecret = secret;
+    }
+    token(token) {
+        this._token = token;
+    }
+    carte(carte) {
+        this._carte = carte;
+    }
+    carteSource(carteSource) {
+        this._carteSource = carteSource;
+    }
+    authMethod(authMethod) {
+        this._authMethod = authMethod;
+    }
+    noAuth() {
+        this.authMethod("none");
+    }
+    auth() {
+        this.authMethod("peer");
+    }
+    authAdmin() {
+        this.authMethod("admin");
+    }
+    authRootAdmin() {
+        this.authMethod("root-admin");
+    }
+    call(name_1, location_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (name, location, { params = null, method = "GET", body = null, contentType = null, auth = true, schema, bodies = false, srcBodies = false }) {
+            let bodyEncoded = null;
+            if (body != null) {
+                if (srcBodies) {
+                    body = encodeBodies(body);
+                }
+                bodyEncoded = JSON.stringify(body);
+            }
+            const headers = {
+                "Accept": "application/json",
+                "Content-Type": contentType !== null && contentType !== void 0 ? contentType : "application/json"
+            };
+            let bearer = null;
+            if (auth) {
+                switch (this._authMethod) {
+                    case "peer":
+                        if (this._carteSource != null) {
+                            bearer = "carte:" + (yield this._carteSource.getCarte());
+                        }
+                        else if (this._carte != null) {
+                            bearer = "carte:" + this._carte;
+                        }
+                        else {
+                            throw new MoeraCallError("Carte is not set");
+                        }
+                        break;
+                    case "admin":
+                        if (this._token == null) {
+                            throw new MoeraCallError("Token is not set");
+                        }
+                        bearer = "token:" + this._token;
+                        break;
+                    case "root-admin":
+                        if (this._rootSecret == null) {
+                            throw new MoeraCallError("Root secret is not set");
+                        }
+                        bearer = "secret:" + this._rootSecret;
+                        break;
+                }
+            }
+            if (bearer != null) {
+                headers["Authorization"] = `Bearer ${bearer}`;
+            }
+            if (this.root == null) {
+                throw new MoeraCallError("Node URL is not set");
+            }
+            let url = (0, util_1.urlWithParameters)(this.root + "/api" + location, params);
+            let response;
+            try {
+                response = yield fetch(url, { method, headers, body: bodyEncoded });
+            }
+            catch (e) {
+                throw new MoeraNodeConnectionError(String(e));
+            }
+            let data;
+            try {
+                if (schema === "blob" && response.ok) {
+                    data = yield response.blob();
+                }
+                else {
+                    data = yield response.json();
+                }
+            }
+            catch (e) {
+                if (!response.ok) {
+                    throw new MoeraNodeError(name, "Server returned error status");
+                }
+                else {
+                    throw new MoeraNodeError(name, "Server returned empty result");
+                }
+            }
+            if (!response.ok) {
+                const { valid } = (0, validate_1.validateSchema)("Result", data);
+                if (!valid) {
+                    throw new MoeraNodeError(name, "Server returned error status");
+                }
+                throw new MoeraNodeApiError(name, data);
+            }
+            if (schema !== "blob") {
+                const result = (0, validate_1.validateSchema)(schema, data);
+                const { valid, errors } = result;
+                if (!valid) {
+                    throw new MoeraNodeError(name, "Server returned incorrect response" + (0, schema_1.formatSchemaErrors)(errors));
+                }
+                if (bodies) {
+                    data = decodeBodies(name, data);
+                }
+            }
+            return data;
+        });
+    }
+}
+exports.Caller = Caller;

package/lib/node/cartes.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoeraCarteSource = exports.MoeraCartesError = void 0;
+class MoeraCartesError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.MoeraCartesError = MoeraCartesError;
+function isAdminCarte(carte) {
+    return carte.permissions == null || carte.permissions.includes("other");
+}
+class MoeraCarteSource {
+    constructor(node) {
+        this.cartes = [];
+        this.node = node;
+    }
+    renew() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cartes = (yield this.node.getCartes()).cartes;
+        });
+    }
+    getCarte() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const renewed of [false, true]) {
+                const now = Math.floor(Date.now() / 1000);
+                this.cartes = this.cartes.filter(c => c.deadline > now && isAdminCarte(c));
+                if (this.cartes.length === 0) {
+                    if (renewed) {
+                        throw new MoeraCartesError("Could not obtain a valid carte from the node");
+                    }
+                    yield this.renew();
+                    continue;
+                }
+                for (const c of this.cartes) {
+                    if (c.beginning <= now) {
+                        return c.carte;
+                    }
+                }
+                throw new MoeraCartesError("Could not obtain a carte valid for now");
+            }
+            throw new MoeraCartesError("Could not obtain a carte valid for now");
+        });
+    }
+}
+exports.MoeraCarteSource = MoeraCarteSource;

package/lib/node/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoeraCartesError = exports.MoeraCarteSource = exports.moeraRoot = exports.MoeraNodeConnectionError = exports.MoeraNodeApiError = exports.MoeraNodeError = exports.MoeraNode = void 0;
+var node_1 = require("./node");
+Object.defineProperty(exports, "MoeraNode", { enumerable: true, get: function () { return node_1.MoeraNode; } });
+var caller_1 = require("./caller");
+Object.defineProperty(exports, "MoeraNodeError", { enumerable: true, get: function () { return caller_1.MoeraNodeError; } });
+Object.defineProperty(exports, "MoeraNodeApiError", { enumerable: true, get: function () { return caller_1.MoeraNodeApiError; } });
+Object.defineProperty(exports, "MoeraNodeConnectionError", { enumerable: true, get: function () { return caller_1.MoeraNodeConnectionError; } });
+Object.defineProperty(exports, "moeraRoot", { enumerable: true, get: function () { return caller_1.moeraRoot; } });
+var cartes_1 = require("./cartes");
+Object.defineProperty(exports, "MoeraCarteSource", { enumerable: true, get: function () { return cartes_1.MoeraCarteSource; } });
+Object.defineProperty(exports, "MoeraCartesError", { enumerable: true, get: function () { return cartes_1.MoeraCartesError; } });