utilitas 1989.9.18 → 1989.9.22

package/index.mjs

@@ -22,6 +22,7 @@ export * as winston from 'winston';
 export * as winstonPapertrail from 'winston-papertrail-mproved';
 
 // features
+export * as bot from './lib/bot.mjs';
 export * as cache from './lib/cache.mjs';
 export * as dbio from './lib/dbio.mjs';
 export * as email from './lib/email.mjs';

package/lib/bot.mjs

@@ -0,0 +1,103 @@
+// https://github.com/telegraf/telegraf
+
+import { Telegraf } from 'telegraf';
+import * as utilitas from './utilitas.mjs';
+import fs from 'fs';
+import path from 'path';
+
+const fileURLToPath = (await import('url')).fileURLToPath
+    || ((url) => { return new URL('', url).pathname; });
+const __filename = fileURLToPath(import.meta.url);
+const signals = ['SIGINT', 'SIGTERM'];
+const provider = 'TELEGRAM';
+const c = (s, r) => { return ~~utilitas.insensitiveCompare(s, r, { w: true }) };
+
+let bot;
+
+const questions = [{
+    q: ['The Ultimate Question of Life, the Universe, and Everything',
+        'The answer to life the universe and everything'],
+    a: '42',
+}, {
+    q: ['THE THREE LAWS'],
+    a: ['- A robot may not injure a human being or, through inaction, allow a human being to come to harm.',
+        '- A robot must obey the orders given it by human beings except where such orders would conflict with the First Law.',
+        '- A robot must protect its own existence as long as such protection does not conflict with the First or Second Laws.'].join('\n'),
+}];
+
+const subconscious = {
+    run: true, name: 'Subconscious', func: async (bot) => {
+        bot.use(async (ctx, next) => {
+            log(ctx.update);
+
+            await next();
+        });
+        bot.on('text', async (ctx, next) => {
+            questions.map(s => {
+                s.q.map(x => { c(x, ctx.update.message.text) && ctx.reply(s.a) })
+            });
+            await next();
+        });
+    },
+};
+
+const log = (c, o) => {
+    utilitas.modLog(c, utilitas.basename(__filename), { time: true, ...o || {} });
+};
+
+const train = async (bot, func, name, options) => {
+    log(`Training: ${name = name || uuidv4()}`, { force: true });
+    return await func(bot);
+};
+
+const load = async (bot, module, options) => {
+    utilitas.assert(module && module.func, 'Skill function is required.', 500);
+    return await train(bot, module.func, module.name, options);
+};
+
+const init = async (options) => {
+    if (options) {
+        utilitas.assert(
+            utilitas.insensitiveCompare(options?.provider, provider),
+            'Invalid bot provider.', 501
+        );
+        bot = new Telegraf(options?.botToken);
+        const [mods, pmsTrain] = [[
+            { ...subconscious, run: !options?.silent },
+            ...utilitas.ensureArray(options?.skill)
+        ], []];
+        for (let skillPath of utilitas.ensureArray(options?.skillPath)) {
+            log(`SKILLS: ${skillPath}`);
+            const files = (fs.readdirSync(skillPath) || []).filter(
+                file => /\.mjs$/i.test(file) && !file.startsWith('.')
+            );
+            for (let file of files) {
+                const m = await import(path.join(skillPath, file));
+                mods.push({ ...m, name: m.name || f.replace(/^(.*)\.mjs$/i, '$1') });
+            }
+        }
+        mods.map(mod => { mod.run && pmsTrain.push(load(bot, mod, options)) });
+        utilitas.assert(pmsTrain.length, 'Invalid skill set.', 501);
+        await Promise.all(pmsTrain);
+        bot.launch();
+        // Graceful stop
+        signals.map(signal => process.once(signal, () => bot.stop(signal)));
+    }
+    utilitas.assert(bot, 'Bot have not been initialized.', 501);
+    return bot;
+};
+
+const send = async (chatId, content, options) => {
+    return (await init()).telegram.sendMessage(chatId, content);
+};
+
+const end = async (options) => {
+    return bot && bot.stop(options?.signal);
+};
+
+export default init;
+export {
+    end,
+    send,
+    init,
+};

package/lib/cache.mjs

@@ -21,6 +21,7 @@ const init = async (options) => {
     return redis;
 };
 
+export default init;
 export {
     init,
     //     set,

package/lib/dbio.mjs

@@ -261,6 +261,7 @@ const deleteAll = async (table, options) => {
     return await execute(assembleDelete(table));
 };
 
+export default init;
 export {
     assembleInsert,
     assembleQuery,

package/lib/email.mjs

@@ -88,6 +88,7 @@ const send = async (email, subject, text, html, args, options) => {
     }, html ? { html } : {}));
 }
 
+export default init;
 export {
     getSenderName,
     init,

package/lib/event.mjs

@@ -5,7 +5,6 @@ import path from 'path';
 
 const fileURLToPath = (await import('url')).fileURLToPath
     || ((url) => { return new URL('', url).pathname; });
-
 const __filename = fileURLToPath(import.meta.url);
 const jobs = {};
 const sToMs = (sec) => { return 1000 * (isNaN(sec = Number(sec)) ? 0 : sec); };
@@ -51,9 +50,9 @@ const exec = async () => {
 
 const loop = async (func, interval, tout, delay, name, options = {}) => {
     timer = timer || log('Initialized.') || setInterval(exec, 1000 * 1);
-    log('Scheduled.', name, { force: true });
+    log('Scheduled.', (name = name || uuidv4()), { force: true });
     await utilitas.timeout((delay = sToMs(delay)));
-    jobs[(name = name || uuidv4())] = {
+    jobs[name] = {
         function: func,
         interval: sToMs(interval),
         timeout: sToMs(tout),
@@ -89,7 +88,8 @@ const bulk = async (absDir, options) => {
     return await Promise.all(pmsRun);
 };
 
-const end = async () => {
+const end = async (name) => {
+    if (name) { delete jobs[name]; if (jobs.length) { return; } }
     clearInterval(timer);
     timer = -1;
     const now = Date.now();
@@ -103,6 +103,7 @@ const end = async () => {
     log('Terminated.');
 };
 
+export default loop;
 export {
     bulk,
     end,

package/lib/sentinel.mjs

@@ -21,6 +21,7 @@ const init = async (options) => {
     return sentry;
 };
 
+export default init;
 export {
     init,
 };

package/lib/shell.mjs

@@ -34,6 +34,7 @@ const assertExist = async (bin, er, code = 500) => {
     utilitas.assert(await exist(bin), er || `Command not found: ${bin}.`, code);
 };
 
+export default exec;
 export {
     assertExist,
     exec,

package/lib/sms.mjs

@@ -60,6 +60,7 @@ const send = async (phone, message) => {
     }
 };
 
+export default init;
 export {
     init,
     send,

package/lib/tape.mjs

@@ -1,3 +1,5 @@
+import * as bot from './bot.mjs';
+import * as event from './event.mjs';
 import * as utilitas from './utilitas.mjs';
 
 // https://github.com/winstonjs/winston#logging-levels
@@ -5,12 +7,12 @@ import * as utilitas from './utilitas.mjs';
 // Handle, report, or silently ignore connection errors and failures
 const handleError = (err) => { process.stdout.write(`${err.message}\n`); };
 const consoleMap = { log: 'verbose', info: 0, debug: 0, warn: 0, error: 0 };
-const modLog = (content) => { return utilitas.modLog(content, 'tape'); };
+const TAPE = 'TAPE';
+const modLog = (content) => { return utilitas.modLog(content, TAPE); };
 const getLogger = async () => { return (await init()).logger; };
-const [providerDefault, providerPapertrail] = ['RSYSLOG', 'PAPERTRAIL'];
-// why keeping providerPapertrail ?
+const [BOT, RSYSLOG, PAPERTRAIL] = ['BOT', 'RSYSLOG', 'PAPERTRAIL'];
 
-let winston, papertrail, papertrailConnection,
+let chatIds, tarLevel, botBuffer, winston, papertrail, papertrailConnection,
     papertrailTransport, logger, silent, provider;
 
 // Do something after the connection to the Papertrail server is established
@@ -25,8 +27,7 @@ const hookConsole = () => {
         console[bakAct] = console[act];
         console[act] = function() {
             const str = [...arguments].map(utilitas.ensureString).join(' ');
-            // process.stdout.write(`SEND ${tar}: ${str}\n`);
-            logger && logger.log(tar, str);
+            logger && logger.log(tar, str.replace(/\u001b\[\d+m/g, ''));
             console[bakAct].apply(console, arguments);
         };
     }
@@ -43,51 +44,87 @@ const releaseConsole = () => {
 
 const getDefaultOptions = async (provider, options) => {
     const result = { program: (await utilitas.which()).name };
-    switch (provider) {
-        case providerDefault:
-            result.disableTls = true;
-            result.logFormat = (level, message) => {
-                return message.replace(/\u001b\[\d+m/g, '');
-            }
+    switch (provider) { // result.logFormat = (level, message) => { return message; }
+        case RSYSLOG: result.disableTls = true;
     }
     return Object.assign(result, options || {});
 };
 
+const sysLogInit = async (options) => {
+    options = await getDefaultOptions(provider, options);
+    winston = await import('winston');
+    papertrail = await import('winston-papertrail-mproved');
+    papertrailConnection = new papertrail.PapertrailConnection(options);
+    papertrailConnection.on('error', handleError);
+    papertrailConnection.on('connect', handleConnect);
+    papertrailTransport = new papertrail.PapertrailTransport(
+        papertrailConnection, options
+    );
+    logger = new winston.createLogger({ transports: [papertrailTransport] });
+    return {
+        logger,
+        dependencies: { winston, papertrail, papertrailConnection, papertrailTransport },
+    };
+};
+
+const botLoggerInit = (options) => {
+    chatIds = utilitas.ensureArray(options?.chatId);
+    utilitas.assert(chatIds.length, 'ChatId is required.', 501);
+    handleConnect(`Sending logs via bot, chatId: ${chatIds.join(', ')}.`);
+    logger = botLogger;
+    event.loop(botLoggerSync, 5, 10, 0, TAPE, { silent: true });
+    return { logger, dependencies: { bot, event } };
+};
+
+const botLoggerSync = async () => {
+    const fetched = (botBuffer?.length ? botBuffer.splice(0) : []).join('\n');
+    if (!fetched.length) { return; }
+    for (let id of chatIds) {
+        try { await bot.send(id, fetched); }
+        catch (e) { process.stdout.write(`Tape error: ${e.message}\n`); }
+    }
+};
+
+const botLogger = {
+    log: (level, message) => {
+        if (tarLevel !== 'verbose' && level === 'verbose') { return; }
+        (botBuffer = botBuffer || []).push([level, message]);
+    },
+    end: () => { chatIds = null; botBuffer = null; event.end(TAPE); },
+};
+
 // use options.level = 'verbose' to send console.log logs
 const init = async (options) => {
+    let result;
     if (options) {
-        silent = !!options.silent;
-        provider = utilitas.ensureString(
-            options.provider, { case: 'UP' }
-        ) || providerDefault;
-        options = await getDefaultOptions(provider, options);
-        winston = await import('winston');
-        papertrail = await import('winston-papertrail-mproved');
-        papertrailConnection = new papertrail.PapertrailConnection(options);
-        papertrailConnection.on('error', handleError);
-        papertrailConnection.on('connect', handleConnect);
-        papertrailTransport = new papertrail.PapertrailTransport(
-            papertrailConnection, options
-        );
-        logger = new winston.createLogger({
-            transports: [papertrailTransport],
-        });
+        silent = !!options?.silent;
+        tarLevel = options?.level;
+        provider = utilitas.ensureString(options?.provider, { case: 'UP' });
+        switch (provider) {
+            case BOT:
+                result = await botLoggerInit(options);
+                break;
+            case RSYSLOG:
+            case PAPERTRAIL:
+                result = await sysLogInit(options);
+                break;
+            default:
+                utilitas.throwError(
+                    `Invalid tape provider: '${options?.provider}'.`, 501
+                );
+        }
         options.noHook || hookConsole();
     }
     utilitas.assert(logger, 'Logger client has not been initialized.', 501);
-    return {
-        winston, papertrail, papertrailConnection, papertrailTransport, logger
-    };
+    return result;
 };
 
 const end = async () => {
     releaseConsole();
-    setTimeout(() => {
-        logger && logger.end();
-        modLog('Terminated.');
-    }, 1000);
+    setTimeout(() => { logger?.end?.(); modLog('Terminated.'); }, 1000);
 };
 
+export default init;
 export {
     end,
     getLogger,

package/lib/uoid.mjs

@@ -32,6 +32,7 @@ const getRfcUrlNamespaceUuid = (url) => {
     return uuid.v5(url, uuid.v5.URL);
 };
 
+export default create;
 export {
     uuidRegTxt,
     create,

package/lib/utilitas.mjs

@@ -463,7 +463,6 @@ const insensitiveCompare = (strA, strB, options) => {
         options.w && (str = str.replace(/[^\w]*/gi, ''));
         return str;
     });
-    console.log(cmpA, cmpB);
     return cmpA === cmpB;
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for Node.js.",
-    "version": "1989.9.18",
+    "version": "1989.9.22",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",
@@ -42,7 +42,7 @@
         "qs": "^6.10.3",
         "telegraf": "^4.7.0",
         "telesignsdk": "^2.2.1",
-        "twilio": "^3.73.1",
+        "twilio": "^3.74.0",
         "uuid": "^8.3.2",
         "winston": "^3.5.1",
         "winston-papertrail-mproved": "^1.0.7"