utilitas 1989.8.52

package/lib/email.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const log = (content) => { return utilitas.modLog(content, 'email'); };
+
+let senderName, senderEmail, provider, engine, client;
+
+const throwInvalidProvider = (message, status) => {
+    utilitas.throwError(message || 'Invalid email provider.', status || 500);
+};
+
+const init = async (options) => {
+    if (options) {
+        utilitas.assert(options.senderEmail, 'Sender email is required.', 500);
+        senderEmail = options.senderEmail;
+        senderName = options.senderName || (await utilitas.which()).name;
+        provider = utilitas.trim(options.provider, { case: 'UP' });
+        switch (provider) {
+            case 'MAILGUN':
+                engine = require('mailgun-js');
+                client = engine(options);
+                break;
+            case 'MAILJET':
+                engine = require('node-mailjet');
+                client = engine.connect(options.apiKey, options.apiSecret);
+                break;
+            default:
+                throwInvalidProvider();
+        }
+        if (!options.silent) {
+            log(`Initialized: ${senderName} <${senderEmail}> via ${provider}.`);
+        }
+    }
+    utilitas.assert(client, 'Email client has not been initialized.', 501);
+    return client;
+};
+
+const getSenderName = () => {
+    return senderName;
+};
+
+const rawSend = async (data) => {
+    let [payload, instance, fromName, fromEmail] = [null, await init(),
+        data.senderName || senderName, data.senderEmail || senderEmail];
+    switch (provider) {
+        case 'MAILGUN':
+            payload = Object.assign({
+                from: `${fromName} <${fromEmail}>`,
+                to: data.to,
+                subject: data.subject,
+                text: data.text,
+            }, data.html ? { html: data.html } : {});
+            return await instance.messages().send(payload);
+        case 'MAILJET':
+            payload = Object.assign({
+                'FromEmail': fromEmail,
+                'FromName': fromName,
+                'Subject': data.subject,
+                'Recipients': data.to.map((eml) => { return { Email: eml }; }),
+                'Text-part': data.text,
+            }, data.html ? { 'Html-part': data.html } : {});
+            return await instance.post('send').request(payload);
+        default:
+            throwInvalidProvider();
+    }
+};
+
+const send = async (email, subject, text, html, args, options) => {
+    options = options || {};
+    email = utilitas.ensureArray(email);
+    for (let i in email) {
+        email[i] = utilitas.trim(email[i]).toLowerCase();
+        utilitas.assertEmail(email[i], 'Invalid email.', 500);
+    }
+    subject = utilitas.trim(subject);
+    text = utilitas.trim(text);
+    html = utilitas.trim(html);
+    utilitas.assert(subject, 'Subject is required.', 500);
+    utilitas.assert(text, 'Text body is required.', 500);
+    for (let i in args || {}) {
+        subject = subject.replace(new RegExp(`{{${i}}}`, 'ig'), args[i]);
+        text = text.replace(new RegExp(`{{${i}}}`, 'ig'), args[i]);
+        html = html.replace(new RegExp(`{{${i}}}`, 'ig'), args[i]);
+    }
+    return await rawSend(Object.assign({
+        senderName: options.senderName, senderEmail: options.senderEmail,
+        to: utilitas.uniqueArray(email), subject, text
+    }, html ? { html } : {}));
+}
+
+module.exports = {
+    getSenderName,
+    init,
+    rawSend,
+    send,
+};
+
+const utilitas = require('./utilitas');
+
+// (async () => {
+//     init({
+//         provider: 'MAILGUN',
+//         apiKey: '',
+//         domain: '',
+//         senderName: 'Leask Wong',
+//         senderEmail: 'i@leaskh.com'
+//     });
+//     init({
+//         provider: 'MAILJET',
+//         apiKey: '',
+//         apiSecret: '',
+//         senderName: 'Leask Wong',
+//         senderEmail: 'i@leaskh.com'
+//     });
+//     console.log(await send(
+//         'i@leaskh.com',
+//         'Hello, World!',
+//         'The quick brown fox jumps over the lazy dog.',
+//         '<html>The quick brown fox jumps over the lazy dog. (HTML)</html>'
+//     ));
+// })();

package/lib/encryption.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const defaultAlgorithm = 'sha256';
+
+const getSortedQueryString = (object) => {
+    const sorted = {};
+    Object.keys(object).sort().map(key => { sorted[key] = object[key]; });
+    return qs.stringify(sorted);
+};
+
+// algorithm = 'sha1', 'md5', 'sha256', 'sha512'...
+const hash = (string, algorithm = defaultAlgorithm) => {
+    return crypto.createHash(algorithm).update(string).digest('hex');
+};
+
+// algorithm = 'sha1', 'md5', 'sha256', 'sha512'...
+const hashFile = (filename, algorithm = defaultAlgorithm) => new Promise(
+    (resolve) => {
+        const hash = crypto.createHash(algorithm);
+        fs.createReadStream(filename)
+            .on('data', data => hash.update(data))
+            .on('end', () => resolve(hash.digest('hex')));
+    }
+);
+
+const sha256 = (string) => {
+    return hash(string);
+};
+
+const sha256File = async (filename) => {
+    return await hashFile(filename);
+};
+
+const random = (length) => {
+    return crypto.randomBytes(length);
+};
+
+const randomString = (length = 128, encoding = 'HEX') => {
+    let byteLength = Math.ceil(~~length / 2);
+    byteLength = byteLength > 0 ? byteLength : 1;
+    return random(byteLength).toString(encoding).substr(0, length);
+};
+
+const digestObject = (object, algorithm) => {
+    return hash(getSortedQueryString(object), algorithm);
+};
+
+module.exports = {
+    defaultAlgorithm,
+    digestObject,
+    getSortedQueryString,
+    hash,
+    hashFile,
+    random,
+    randomString,
+    sha256,
+    sha256File,
+};
+
+const crypto = require('crypto');
+const fs = require('fs');
+const qs = require('qs');

package/lib/event.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const jobs = {};
+
+let timer = null;
+
+const sToMs = (sec) => { return 1000 * (isNaN(sec = Number(sec)) ? 0 : sec); };
+
+const unLock = (name) => { return jobs[name].lock = 0; };
+
+const list = () => { return jobs; };
+
+const log = (content, job, options) => {
+    options = Object.assign({ time: true }, options || {});
+    if (!job || !jobs[job] || !jobs[job].silent
+        || options.force || content instanceof Error) {
+        utilitas.modLog(
+            content, utilitas.basename(__filename) + (job ? ` > ${job}` : ''),
+            options
+        );
+    }
+};
+
+const tryLock = (name, now, timeout) => {
+    return (jobs[name].lock + timeout > now)
+        ? jobs[name].lock
+        : !(jobs[name].lock = now);
+};
+
+const exec = async () => {
+    const now = Date.now();
+    for (let i in jobs) {
+        if (jobs[i].lastRun + jobs[i].interval < now) {
+            jobs[i].lastRun = now;
+            try {
+                if (tryLock(i, now, jobs[i].timeout)) {
+                    log('Locked, skipped.', i);
+                    continue;
+                }
+                log('Emit...', i);
+                await jobs[i].function();
+            } catch (err) {
+                log(err, i);
+            }
+            log('Done.', i);
+            unLock(i);
+        }
+    }
+};
+
+const loop = async (func, interval, tout, delay, name, options = {}) => {
+    timer = timer || log('Initialized.') || setInterval(exec, 1000 * 1);
+    log('Scheduled.', name, { force: true });
+    await utilitas.timeout((delay = sToMs(delay)));
+    jobs[(name = name || uuidv4())] = {
+        function: func,
+        interval: sToMs(interval),
+        timeout: sToMs(tout),
+        delay: delay,
+        lastRun: 0,
+        lock: 0,
+        silent: !!options.silent,
+        end: options.end,
+    };
+    return timer;
+};
+
+const load = async (module, options = {}) => {
+    utilitas.assert(module && module.func, 'Event function is required.', 500);
+    return await loop(
+        module.func, module.interval, module.tout, module.delay, module.name,
+        options
+    );
+};
+
+const bulk = async (absDir, options) => {
+    options = options || {};
+    const pms = [];
+    log(`SERVICES: ${absDir}`);
+    (fs.readdirSync(absDir) || []).filter((file) => {
+        return /\.js$/i.test(file) && file.indexOf('.') !== 0;
+    }).forEach((file) => {
+        const filename = file.replace(/^(.*)\.js$/i, '$1');
+        const mod = require(path.join(absDir, file));
+        if (mod.run) {
+            mod.name = mod.name || filename;
+            pms.push(load(mod, options));
+        }
+    });
+    return await Promise.all(pms);
+};
+
+const end = async () => {
+    clearInterval(timer);
+    timer = -1;
+    const now = Date.now();
+    for (let i in jobs) {
+        if (jobs[i].end) { try { await jobs[i].end(); } catch (e) { }; }
+        while (tryLock(i, now, jobs[i].timeout)) {
+            log('Waiting...', i); await utilitas.timeout(1000);
+        }
+        log('End.', i);
+    }
+    log('Terminated.');
+};
+
+module.exports = {
+    bulk,
+    list,
+    load,
+    loop,
+    end,
+};
+
+const utilitas = require('./utilitas');
+const uuidv4 = require('uuid').v4;
+const path = require('path');
+const fs = require('fs');

package/lib/network.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const log = (content) => { return utilitas.modLog(content, 'network'); };
+
+const ping = async (host, options = { timeout: 3, min_reply: 3 }) => {
+    await shell.assertExist('ping');
+    return await libPing.promise.probe(host, options);
+};
+
+const pickFastestHost = async (hosts, options = {}) => {
+    let [reqHosts, pingResp, pasResp, result]
+        = [utilitas.ensureArray(hosts), [], [], null];
+    reqHosts.map(x => {
+        try { x = new URL(x).hostname; } catch (e) { }
+        pingResp.push(ping(x));
+    });
+    pingResp = await Promise.all(pingResp);
+    pingResp.map(x => {
+        if (x.alive) { pasResp.push(x); }
+        if (options.debug) {
+            let logs = [];
+            for (let i in x) {
+                if (!['output', 'times', 'stddev'].includes(i)) {
+                    logs.push(`${i}: ${x[i]}`);
+                }
+            }
+            log(`ping > ${logs.join(', ')}`);
+        }
+    });
+    if (pingResp.length && pasResp.length) {
+        pasResp.sort((x, y) => {
+            return Number(x.packetLoss) - Number(y.packetLoss)
+                || Number(x.avg) - Number(y.avg);
+        });
+        for (let x of reqHosts) {
+            if (x.includes(pasResp[0].host)) { result = x; break; }
+        }
+    }
+    if (!result) {
+        if (options.forcePick) { result = reqHosts[0]; } else {
+            utilitas.throwError('All hosts cannot be connected.', 500);
+        }
+    }
+    if (options.debug) { log(`picked > ${result}`); }
+    return result;
+};
+
+const httping = async (url, options = { timeout: 3 }) => { // @todo: timeout
+    let [response, error, stTime] = [null, null, new Date()];
+    try { response = await fetch(url); } catch (e) { error = e; }
+    return {
+        url, response, error, response_time: error ? null : new Date() - stTime
+    };
+};
+
+const pickFastestHttpServer = async (urls, options = {}) => {
+    urls = utilitas.ensureArray(urls);
+    const resp = await Promise.all(urls.map(u => { return httping(u); }));
+    const result = [];
+    resp.map(x => {
+        try { delete r.response; } catch (e) { }
+        let logs = [];
+        if (options.debug) {
+            for (let i in x) {
+                if (!['error', 'response'].includes(i)) {
+                    logs.push(`${i}: ${x[i]}`);
+                }
+            }
+            log(`httping > ${logs.join(', ')}`);
+        }
+        if (!x.error) { result.push(x); }
+    });
+    result.sort((x, y) => { return x.response_time - y.response_time; });
+    let pick = result.length ? result[0].url : null;
+    if (!pick) {
+        if (options.forcePick) { pick = urls[0]; } else {
+            utilitas.throwError('All hosts cannot be connected.', 500);
+        }
+    }
+    if (options.debug) { log(`picked > ${pick}`); }
+    return pick;
+};
+
+const getCurrentPosition = async () => {
+    const ip = await publicIp.v4();
+    utilitas.assert(ip, 'Network is unreachable.', 500);
+    const loc = await geoIp.lookup(ip);
+    utilitas.assert(loc, 'Error detecting geolocation.', 500);
+    return Object.assign(loc, { ip });
+};
+
+module.exports = {
+    getCurrentPosition,
+    httping,
+    pickFastestHost,
+    pickFastestHttpServer,
+    ping,
+};
+
+const utilitas = require('./utilitas');
+const publicIp = require('public-ip');
+const libPing = require('ping');
+const fetch = require('node-fetch').default;
+const geoIp = require('fast-geoip');
+const shell = require('./shell');

package/lib/sentinel.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const log = (str, opts) => { return utilitas.modLog(str, 'sentinel', opts); };
+
+let sentry = null;
+
+const integrations = (integrations) => {
+    return integrations.filter(x => {
+        if (x.name === 'OnUnhandledRejection') { x._options.mode = 'strict'; }
+        return x;
+    });
+};
+
+const init = async (options) => {
+    if (options) {
+        sentry = require('@sentry/node');
+        sentry.init(Object.assign({ integrations }, options));
+        if (!options.silent) { log(`Initialized, dsn: ${options.dsn} .`); }
+    }
+    utilitas.assert(sentry, 'Sentry has not been initialized.', 501);
+    return sentry;
+};
+
+module.exports = {
+    init,
+};
+
+const utilitas = require('./utilitas');

package/lib/shell.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const log = (content) => { return utilitas.modLog(content, 'shell'); };
+const vf = (cmd, cbf) => { log(`Can not run in browser: ${cmd}`); cbf(); };
+
+const assertCommand = (command) => {
+    utilitas.assert(command, 'Command is required.', 500);
+};
+
+const exec = async (command, options = {}) => {
+    assertCommand(command);
+    const { stdout, stderr } = await pmsExec(command);
+    utilitas.assert(!stderr, stderr, 500);
+    return stdout;
+};
+
+const which = async (bin) => {
+    assertCommand(bin);
+    let binPath = null;
+    try { binPath = await exec(`which ${bin}`); } catch (err) { }
+    return binPath;
+};
+
+const exist = async (bin) => {
+    assertCommand(bin);
+    return !!await which(bin);
+};
+
+const assertExist = async (bin, er, code = 500) => {
+    assertCommand(bin);
+    utilitas.assert(await exist(bin), er || `Command not found: ${bin}.`, code);
+};
+
+module.exports = {
+    assertExist,
+    exec,
+    exist,
+    which,
+};
+
+const childProcess = require('child_process');
+const utilitas = require('./utilitas');
+const util = require('util');
+const pmsExec = util.promisify(childProcess && childProcess?.exec || vf);