@vbarbarosh/node-helpers 3.12.0 → 3.14.0

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "3.12.0",
+    "version": "3.14.0",
     "description": "A set of helpers for JavaScript/Node.js",
     "files": [
         "src"

package/src/mongo_stream_upsert.js

@@ -3,17 +3,28 @@ const stream = require('stream');
 const wait_while = require('./wait_while');
 
 /**
- * Returns a writable stream for upsert mongo collection.
+ * Returns a writable stream for inserting, or conditionally updating, documents in mongo collection.
  */
-function mongo_stream_upsert({collection, concurrency = 1})
+function mongo_stream_upsert({collection, update_if, concurrency = 1})
 {
+    const errors = [];
     return new stream.Writable({
         objectMode: true,
         construct(next) {
             this.running = 0;
             next();
         },
+        destroy: async function (error, next) {
+            // console.log('mongo_stream_upsert.destroy', errors);
+            await wait_while(() => this.running > 0);
+            next();
+        },
         write: async function (items, enc, next) {
+            // console.log('mongo_stream_upsert.write', errors);
+            if (errors.length) {
+                next(errors[0]);
+                return;
+            }
             try {
                 if (!Array.isArray(items)) {
                     next(new Error('An array of objects is expected.'));
@@ -21,10 +32,33 @@ function mongo_stream_upsert({collection, concurrency = 1})
                 }
                 await wait_while(() => this.running >= concurrency);
                 const operations = items.map(function (item) {
-                    return {replaceOne: {filter: {_id: item._id}, replacement: item, upsert: true}};
+                    if (!update_if) {
+                        return {
+                            replaceOne: {
+                                filter: {_id: item._id},
+                                replacement: item,
+                                upsert: true,
+                            },
+                        };
+                    }
+                    return {
+                        updateOne: {
+                            filter: {_id: item._id},
+                            update: [[
+                                {
+                                    $replaceRoot: {
+                                        newRoot: {
+                                            $cond: [update_if, item, '$$ROOT'],
+                                        },
+                                    },
+                                },
+                            ]],
+                            upsert: true,
+                        },
+                    };
                 });
                 this.running++;
-                Promise.resolve(collection.bulkWrite(operations, {multi: true})).finally(() => this.running--);
+                Promise.resolve(collection.bulkWrite(operations, {multi: true})).catch(e => errors.push(e)).finally(() => this.running--);
                 next();
             }
             catch (error) {
@@ -32,6 +66,11 @@ function mongo_stream_upsert({collection, concurrency = 1})
             }
         },
         final: async function (next) {
+            // console.log('mongo_stream_upsert.final', errors);
+            if (errors.length) {
+                next(errors[0]);
+                return;
+            }
             await wait_while(() => this.running > 0);
             next();
         },

package/src/sanitize_dash_name.js

@@ -0,0 +1,7 @@
+function sanitize_dash_name(s)
+{
+    // https://stackoverflow.com/a/37511463
+    return s.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-zA-Z0-9]/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
+}
+
+module.exports = sanitize_dash_name;

package/src/sanitize_dash_name.test.js

@@ -0,0 +1,59 @@
+const assert = require('assert');
+const sanitize_dash_name = require('./sanitize_dash_name');
+
+const items = [
+    ['', ''],
+    ['', '.'],
+    ['', 'привет'],
+    ['1-2-3', '1-2-3'],
+    ['1-2-3', '1.2.3'],
+    ['1000-stories', '1000 Stories'],
+    ['1800', '1800'],
+    ['3-a', '3-A'],
+    ['43', '43'],
+    ['600-d', '600+D'],
+    ['9-lives', '9 Lives'],
+    ['a-c-d', 'A, C, D'],
+    ['a-f', 'A F'],
+    ['accua-aseptic-solucion', 'Accua Aséptic Solución'],
+    ['acido-acetilsalicilico', 'Ácido Acetilsalicílico'],
+    ['acido-nalidixico-fenazopiridina', 'Ácido Nalidixico-Fenazopiridina'],
+    ['aeropostale', 'Aéropostale'],
+    ['arnica-nartex', 'Árnica Nártex'],
+    ['art-n-chef', 'Art \'n Chef'],
+    ['b-a-r-t-e-r', 'B.A.R.T.E.R.'],
+    ['b-oost', 'b:oost'],
+    ['betametasona-clotrimazol-gentamicina', 'Betametasona - Clotrimazol - Gentamicina'],
+    ['black-decker', 'Black & Decker'],
+    ['black-decker', 'Black + Decker'],
+    ['black-panther', 'Black Panther'],
+    ['black-white', 'Black & White'],
+    ['blanca-nieves', 'Blanca Nieves'],
+    ['de-rancho', 'de Rancho'],
+    ['del-valle', 'del Valle'],
+    ['exportacion-selecto', 'Exportación Selecto'],
+    ['extra', 'Extra'],
+    ['ezetimiba-simvastatina', 'Ezetimiba Simvastatina'],
+    ['facicam-gel-90g', 'FACICAM GEL 90G'],
+    ['folios', 'FOLIOS'],
+    ['fresh-garden', 'FRESH GARDEN'],
+    ['gi-valproato-de-magnesio', '(GI) Valproato de Magnesio'],
+    ['itrac-100mg-c-f-15c', 'ITRAC 100MG C/F 15C'],
+    ['m-m-s', 'M&M\'s'],
+    ['m-m-s', 'M&M´s'],
+    ['meticel-0-5', 'Meticel 0.5 %'],
+    ['meticel-2', 'Meticel 2%'],
+    ['opera-prima', 'Ópera Prima'],
+    ['oxido-de-zinc', 'Óxido de Zinc'],
+    ['r-u-m-b-a', 'r u m b a'],
+    ['r-u-m-b-a', 'r_u_m_b_a'],
+    ['ssh-authorized-keys', '~/.\u0000ssh/authorized_keys";\n'],
+];
+
+describe('sanitize_dash_name', function () {
+    items.forEach(function ([expected, input],) {
+        it(`${input} → ${expected}`, function () {
+            assert.deepStrictEqual(sanitize_dash_name(input), expected);
+        });
+    });
+});

package/src/sanitize_filename.js

@@ -0,0 +1,8 @@
+const lib = require('sanitize-filename');
+
+function sanitize_filename(filename)
+{
+    return lib(filename);
+}
+
+module.exports = sanitize_filename;

package/src/stream_multiplex.js

@@ -0,0 +1,51 @@
+const ignore = require('./ignore');
+const stream = require('stream');
+const wait_while = require('./wait_while');
+
+function stream_multiplex(...streams)
+{
+    // `new stream.Writable()` will ignore second, third, etc. calls to `destroy`
+    return stream.Writable({
+        objectMode: true,
+        construct: function (next) {
+            streams.forEach(s => s.once('error', e => this.destroy(e)));
+            next();
+        },
+        destroy: async function (error, next) {
+            let running = streams.length;
+            streams.forEach(s => s.destroy(error, () => running--));
+            await wait_while(() => running > 0);
+            next();
+        },
+        write: async function (chunk, enc, next) {
+            let running = streams.length;
+            streams.forEach(function (stream) {
+                stream.write(chunk, function (error) {
+                    running--;
+                    if (error) {
+                        next(error);
+                        next = ignore;
+                    }
+                });
+            });
+            await wait_while(() => running > 0);
+            next();
+        },
+        final: async function (next) {
+            let running = streams.length;
+            streams.forEach(function (stream) {
+                stream.end(function (error) {
+                    running--;
+                    if (error) {
+                        next(error);
+                        next = ignore;
+                    }
+                });
+            });
+            await wait_while(() => running > 0);
+            next();
+        },
+    });
+}
+
+module.exports = stream_multiplex;

package/src/stream_multiplex.test.js

@@ -0,0 +1,67 @@
+const assert = require('assert');
+const ignore = require('./ignore');
+const stream = require('stream');
+const stream_multiplex = require('./stream_multiplex');
+
+describe('stream_multiplex', function () {
+    it('basic', async function () {
+        const input = [1, 2, 3, 'str1'];
+        const rs = stream.Readable.from(input);
+        const ws1 = stream_debug();
+        const ws2 = stream_debug();
+        await stream.promises.pipeline(rs, stream_multiplex(ws1, ws2));
+        assert.deepStrictEqual(ws1.items, input);
+        assert.deepStrictEqual(ws2.items, input);
+        assert.deepStrictEqual(ws1.events.map(v => v.name), ['finish', 'close']);
+        assert.deepStrictEqual(ws2.events.map(v => v.name), ['finish', 'close']);
+    });
+    it('should throw after first error', async function () {
+        const input = [1, 2, 3, 'str1'];
+        const fail_at = 2;
+        const rs = stream.Readable.from(input);
+        const ws1 = stream_debug();
+        const ws2 = stream_debug();
+        const p = stream.promises.pipeline(rs, stream_multiplex(ws1, ws2, stream_fail_at(fail_at)));
+        await assert.rejects(p, new Error(`Failed at ${fail_at}`));
+        assert.deepStrictEqual(ws1.items, input.slice(0, fail_at));
+        assert.deepStrictEqual(ws2.items, input.slice(0, fail_at));
+        assert.deepStrictEqual(ws1.events.map(v => v.name), ['error', 'close']);
+        assert.deepStrictEqual(ws2.events.map(v => v.name), ['error', 'close']);
+    });
+});
+
+function stream_debug()
+{
+    const out = new stream.Writable({
+        objectMode: true,
+        write: function (item, enc, next) {
+            out.items.push(item);
+            next();
+        },
+    });
+    out.items = [];
+    out.events = [];
+    out.once('close', (...args) => out.events.push({name: 'close', args})); // result of `destroy`
+    out.once('drain', (...args) => out.events.push({name: 'drain', args}));
+    out.once('error', (...args) => out.events.push({name: 'error', args}));
+    out.once('finish', (...args) => out.events.push({name: 'finish', args})); // result of `end`
+    out.once('pipe', (...args) => out.events.push({name: 'pipe', args}));
+    out.once('unpipe', (...args) => out.events.push({name: 'unpipe', args}));
+    return out;
+}
+
+function stream_fail_at(at)
+{
+    let counter = 0;
+    return new stream.Writable({
+        objectMode: true,
+        write: function (item, enc, next) {
+            if (++counter >= at) {
+                next(new Error(`Failed at ${at}`));
+            }
+            else {
+                next();
+            }
+        },
+    });
+}

package/src/fs_path_sanitize.js

@@ -1,8 +0,0 @@
-const sanitize_filename = require('sanitize-filename');
-
-function fs_path_sanitize(filename)
-{
-    return sanitize_filename(filename);
-}
-
-module.exports = fs_path_sanitize;