@steedos/service-package-registry 2.1.10 → 2.1.14

package/main/default/util/i18n.js

@@ -0,0 +1,234 @@
+/**
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * @ignore
+ **/
+
+/**
+ * Internationalization utilities
+ * @mixin @node-red/util_i18n
+ */
+
+var i18n = require("i18next");
+
+var path = require("path");
+var fs = require("fs-extra");
+
+var defaultLang = "en-US";
+
+var resourceMap = {};
+var resourceCache = {};
+var initPromise;
+
+/**
+ * Register multiple message catalogs with i18n.
+ * @memberof @node-red/util_i18n
+ */
+function registerMessageCatalogs(catalogs) {
+    var promises = catalogs.map(function(catalog) {
+        return registerMessageCatalog(catalog.namespace,catalog.dir,catalog.file).catch(err => {});
+    });
+    return Promise.all(promises);
+}
+
+/**
+ * Register a message catalog with i18n.
+ * @memberof @node-red/util_i18n
+ */
+async function registerMessageCatalog(namespace,dir,file) {
+    return initPromise.then(function() {
+        return new Promise((resolve,reject) => {
+            resourceMap[namespace] = { basedir:dir, file:file, lngs: []};
+            fs.readdir(dir,function(err, files) {
+                if (err) {
+                    resolve();
+                } else {
+                    files.forEach(function(f) {
+                        if (fs.existsSync(path.join(dir,f,file))) {
+                            resourceMap[namespace].lngs.push(f);
+                        }
+                    });
+                    i18n.loadNamespaces(namespace,function() {
+                        resolve();
+                    });
+                }
+            })
+        });
+    });
+}
+
+function mergeCatalog(fallback,catalog) {
+    for (var k in fallback) {
+        if (fallback.hasOwnProperty(k)) {
+            if (!catalog[k]) {
+                catalog[k] = fallback[k];
+            } else if (typeof fallback[k] === 'object') {
+                mergeCatalog(fallback[k],catalog[k]);
+            }
+        }
+    }
+}
+
+
+async function readFile(lng, ns) {
+    if (/[^a-z\-]/i.test(lng)) {
+        throw new Error("Invalid language: "+lng)
+    }
+    if (resourceCache[ns] && resourceCache[ns][lng]) {
+        return resourceCache[ns][lng];
+    } else if (resourceMap[ns]) {
+        const file = path.join(resourceMap[ns].basedir, lng, resourceMap[ns].file);
+        const content = await fs.readFile(file, "utf8");
+        resourceCache[ns] = resourceCache[ns] || {};
+        resourceCache[ns][lng] = JSON.parse(content.replace(/^\uFEFF/, ''));
+        var baseLng = lng.split('-')[0];
+        if (baseLng !== lng && resourceCache[ns][baseLng]) {
+            mergeCatalog(resourceCache[ns][baseLng], resourceCache[ns][lng]);
+        }
+        if (lng !== defaultLang) {
+            mergeCatalog(resourceCache[ns][defaultLang], resourceCache[ns][lng]);
+        }
+        return resourceCache[ns][lng];
+    } else {
+        throw new Error("Unrecognised namespace");
+    }
+}
+
+var MessageFileLoader = {
+    type: "backend",
+    init: function (services, backendOptions, i18nextOptions) { },
+    read: function (lng, ns, callback) {
+        readFile(lng, ns)
+            .then(data => callback(null, data))
+            .catch(err => {
+                if (/-/.test(lng)) {
+                    // if reading language file fails -> try reading base language (e. g. 'fr' instead of 'fr-FR' or 'de' for 'de-DE')
+                    var baseLng = lng.split('-')[0];
+                    readFile(baseLng, ns).then(baseData => callback(null, baseData)).catch(err => callback(err));
+                } else {
+                    callback(err);
+                }
+            });
+    }
+}
+
+function getCurrentLocale() {
+    var env = process.env;
+    for (var name of ['LC_ALL', 'LC_MESSAGES', 'LANG']) {
+        if (name in env) {
+            var val = env[name];
+            return val.substring(0, 2);
+        }
+    }
+    return undefined;
+}
+
+function init(settings) {
+    if (!initPromise) {
+        // Keep this as a 'when' promise as top-level red.js uses 'otherwise'
+        // and embedded users of NR may have copied that.
+        initPromise = new Promise((resolve,reject) => {
+            i18n.use(MessageFileLoader);
+            var opt = {
+                // debug: true,
+                defaultNS: "runtime",
+                ns: [],
+                fallbackLng: defaultLang,
+                interpolation: {
+                    unescapeSuffix: 'HTML',
+                    escapeValue: false,
+                    prefix: '__',
+                    suffix: '__'
+                }
+            };
+            var lang = settings.lang || getCurrentLocale();
+            if (lang) {
+                opt.lng = lang;
+            }
+            i18n.init(opt ,function() {
+                resolve();
+            });
+        });
+    }
+}
+
+
+/**
+ * Gets a message catalog.
+ * @name catalog
+ * @function
+ * @memberof @node-red/util_i18n
+ */
+function getCatalog(namespace,lang) {
+    var result = null;
+    lang = lang || defaultLang;
+    if (/[^a-z\-]/i.test(lang)) {
+        throw new Error("Invalid language: "+lng)
+    }
+
+    if (resourceCache.hasOwnProperty(namespace)) {
+        result = resourceCache[namespace][lang];
+        if (!result) {
+            var langParts = lang.split("-");
+            if (langParts.length == 2) {
+                result = resourceCache[namespace][langParts[0]];
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * Gets a list of languages a given catalog is available in.
+ * @name availableLanguages
+ * @function
+ * @memberof @node-red/util_i18n
+ */
+function availableLanguages(namespace) {
+    if (resourceMap.hasOwnProperty(namespace)) {
+        return resourceMap[namespace].lngs
+    }
+}
+
+var obj = module.exports = {
+    init: init,
+    registerMessageCatalog: registerMessageCatalog,
+    registerMessageCatalogs: registerMessageCatalogs,
+    catalog: getCatalog,
+    availableLanguages: availableLanguages,
+    /**
+     * The underlying i18n library for when direct access is really needed
+     */
+    i: i18n,
+    /**
+     * The default language of the runtime
+     */
+    defaultLang: defaultLang
+}
+
+/**
+ * Perform a message catalog lookup.
+ * @name _
+ * @function
+ * @memberof @node-red/util_i18n
+ */
+obj['_'] = function() {
+    //var opts = {};
+    //if (def) {
+    //    opts.defaultValue = def;
+    //}
+    //console.log(arguments);
+    var res = i18n.t.apply(i18n,arguments);
+    return res;
+}

package/main/default/util/index.js

@@ -0,0 +1,81 @@
+/*!
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
+const log = require("./log");
+const i18n = require("./i18n");
+const util = require("./util");
+const events = require("./events");
+const exec = require("./exec");
+const hooks = require("./hooks");
+
+/**
+ * This module provides common utilities for the Node-RED runtime and editor
+ *
+ * @namespace @node-red/util
+ */
+module.exports = {
+    /**
+    * Initialise the module with the runtime settings
+    * @param {Object} settings
+    * @memberof @node-red/util
+    */
+    init: function(settings) {
+        log.init(settings);
+        i18n.init(settings);
+    },
+
+    /**
+    * Logging utilities
+    * @mixes @node-red/util_log
+    * @memberof @node-red/util
+    */
+    log: log,
+
+    /**
+    * Internationalization utilities
+    * @mixes @node-red/util_i18n
+    * @memberof @node-red/util
+    */
+    i18n: i18n,
+
+    /**
+    * General utilities
+    * @mixes @node-red/util_util
+    * @memberof @node-red/util
+    */
+    util: util,
+
+    /**
+    * Runtime events
+    * @mixes @node-red/util_event
+    * @memberof @node-red/util
+    */
+    events: events,
+
+    /**
+    * Run system commands with event-log integration
+    * @mixes @node-red/util_exec
+    * @memberof @node-red/util
+    */
+    exec: exec,
+
+    /**
+    * Runtime hooks
+    * @mixes @node-red/util_hooks
+    * @memberof @node-red/util
+    */
+    hooks: hooks
+}

package/main/default/util/log.js

@@ -0,0 +1,233 @@
+/*!
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
+/**
+ * Logging utilities
+ * @mixin @node-red/util_log
+ */
+
+var util = require("util");
+var EventEmitter = require("events").EventEmitter;
+
+var i18n = require("./i18n");
+
+var levels = {
+    off:    1,
+    fatal:  10,
+    error:  20,
+    warn:   30,
+    info:   40,
+    debug:  50,
+    trace:  60,
+    audit:  98,
+    metric: 99
+};
+
+var levelNames = {
+    10: "fatal",
+    20: "error",
+    30: "warn",
+    40: "info",
+    50: "debug",
+    60: "trace",
+    98: "audit",
+    99: "metric"
+};
+
+var logHandlers = [];
+
+var verbose;
+
+var metricsEnabled = false;
+
+var LogHandler = function(settings) {
+    this.logLevel  = settings ? levels[settings.level]||levels.info : levels.info;
+    this.metricsOn = settings ? settings.metrics||false : false;
+    this.auditOn = settings ? settings.audit||false : false;
+
+    metricsEnabled = metricsEnabled || this.metricsOn;
+
+    this.handler   = (settings && settings.handler) ? settings.handler(settings) : consoleLogger;
+    this.on("log",function(msg) {
+        if (this.shouldReportMessage(msg.level)) {
+            this.handler(msg);
+        }
+    });
+}
+util.inherits(LogHandler, EventEmitter);
+
+LogHandler.prototype.shouldReportMessage = function(msglevel) {
+    return (msglevel == log.METRIC && this.metricsOn) ||
+           (msglevel == log.AUDIT && this.auditOn) ||
+           msglevel <= this.logLevel;
+}
+
+var consoleLogger = function(msg) {
+    if (msg.level == log.METRIC || msg.level == log.AUDIT) {
+        util.log("["+levelNames[msg.level]+"] "+JSON.stringify(msg));
+    } else {
+        if (verbose && msg.msg && msg.msg.stack) {
+            util.log("["+levelNames[msg.level]+"] "+(msg.type?"["+msg.type+":"+(msg.name||msg.id)+"] ":"")+msg.msg.stack);
+        } else {
+            var message = msg.msg;
+            try {
+                if (typeof message === 'object' && message !== null && message.toString() === '[object Object]' && message.message) {
+                    message = message.message;
+                }
+            } catch(e){
+                message = 'Exception trying to log: '+util.inspect(message);
+            }
+
+            util.log("["+levelNames[msg.level]+"] "+(msg.type?"["+msg.type+":"+(msg.name||msg.id)+"] ":"")+message);
+        }
+    }
+}
+
+
+var log = module.exports = {
+
+    FATAL:  10,
+    ERROR:  20,
+    WARN:   30,
+    INFO:   40,
+    DEBUG:  50,
+    TRACE:  60,
+    AUDIT:  98,
+    METRIC: 99,
+
+    init: function(settings) {
+        metricsEnabled = false;
+        logHandlers = [];
+        var loggerSettings = {};
+        verbose = settings.verbose;
+        if (settings.logging) {
+            var keys = Object.keys(settings.logging);
+            if (keys.length === 0) {
+                log.addHandler(new LogHandler());
+            } else {
+                for (var i=0, l=keys.length; i<l; i++) {
+                    var config = settings.logging[keys[i]];
+                    loggerSettings = config || {};
+                    if ((keys[i] === "console") || config.handler) {
+                        log.addHandler(new LogHandler(loggerSettings));
+                    }
+                }
+            }
+        } else {
+            log.addHandler(new LogHandler());
+        }
+    },
+
+    /**
+     * Add a log handler function
+     * @memberof @node-red/util_log
+     */
+    addHandler: function(func) {
+        logHandlers.push(func);
+    },
+
+    /**
+     * Remove a log handler function
+     * @memberof @node-red/util_log
+     */
+    removeHandler: function(func) {
+        var index = logHandlers.indexOf(func);
+        if (index > -1) {
+            logHandlers.splice(index,1);
+        }
+    },
+
+    /**
+     * Log a message object
+     * @memberof @node-red/util_log
+     */
+    log: function(msg) {
+        msg.timestamp = Date.now();
+        logHandlers.forEach(function(handler) {
+            handler.emit("log",msg);
+        });
+    },
+
+    /**
+     * Log a message at INFO level
+     * @memberof @node-red/util_log
+     */
+    info: function(msg) {
+        log.log({level:log.INFO,msg:msg});
+    },
+
+    /**
+     * Log a message at WARN level
+     * @memberof @node-red/util_log
+     */
+    warn: function(msg) {
+        log.log({level:log.WARN,msg:msg});
+    },
+
+    /**
+     * Log a message at ERROR level
+     * @memberof @node-red/util_log
+     */
+    error: function(msg) {
+        log.log({level:log.ERROR,msg:msg});
+    },
+
+    /**
+     * Log a message at TRACE level
+     * @memberof @node-red/util_log
+     */
+    trace: function(msg) {
+        log.log({level:log.TRACE,msg:msg});
+    },
+
+    /**
+     * Log a message at DEBUG level
+     * @memberof @node-red/util_log
+     */
+    debug: function(msg) {
+        log.log({level:log.DEBUG,msg:msg});
+    },
+
+    /**
+     * Check if metrics are enabled
+     * @memberof @node-red/util_log
+     */
+    metric: function() {
+        return metricsEnabled;
+    },
+
+    /**
+     * Log an audit event.
+     * @memberof @node-red/util_log
+     */
+    audit: function(msg,req) {
+        msg.level = log.AUDIT;
+        if (req) {
+            msg.user = req.user;
+            msg.path = req.path;
+            msg.ip = req.ip || (req.headers && req.headers['x-forwarded-for']) || (req.connection && req.connection.remoteAddress) || undefined;
+        }
+        log.log(msg);
+    }
+}
+
+/**
+ * Perform a message catalog lookup.
+ * @name _
+ * @function
+ * @memberof @node-red/util_log
+ */
+log["_"] = i18n._;