@vbarbarosh/node-helpers 2.1.0 → 2.3.0

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "2.1.0",
+    "version": "2.3.0",
     "description": "A set of helpers for JavaScript/Node.js",
     "files": [
         "src"
@@ -31,6 +31,10 @@
     },
     "devDependencies": {
         "mocha": "^10.2.0",
-        "throttle": "^1.0.3"
+        "throttle": "^1.0.3",
+        "redis-v1": "npm:redis@1",
+        "redis-v2": "npm:redis@2",
+        "redis-v3": "npm:redis@3",
+        "redis-v4": "npm:redis@4"
     }
 }

package/src/fs_mkdirp.js

@@ -19,8 +19,13 @@ async function fs_mkdirp(pathname)
         }
         catch (error) {
             // Error: EEXIST: file already exists, mkdir [...]
-            if (error.code == 'EEXIST') {
-                break;
+            if (error.code === 'EEXIST') {
+                // Exiting here is not correct. When two processes are running in parallel,
+                // one tries to create `a/b/c` and another `a`. When second process creates
+                // `a`, the first process will get `EEXIST` and stops (break) creating any
+                // nested directories, which is not correct.
+                // break;
+                continue;
             }
             throw error;
         }

package/src/fs_mkdirp.test.js

@@ -12,4 +12,13 @@ describe('fs_mkdirp', function () {
             assert(await fs_fi(tmp).then(v => v.isDirectory()));
         });
     });
+    it('should create the same directory structure in parallel', async function () {
+        await fs_tempdir(async function (d) {
+            const tmp = fs_path_resolve(d, 'a/b/c/d/e/f/g/h');
+            await Promise.all(Array(10).fill(tmp).map(async function () {
+                await fs_mkdirp(tmp);
+                assert(await fs_fi(tmp).then(v => v.isDirectory()));
+            }));
+        });
+    });
 });

package/src/redis_lshift.js

@@ -1,7 +1,16 @@
 async function redis_lshift(redis, queue, limit = 1)
 {
     const last = limit - 1;
-    const [items] = await redis.multi().lrange(queue, 0, last).ltrim(queue, limit, -1).exec_p();
+    if (redis.lrange) {
+        const [items] = await new Promise(function (resolve, reject) {
+            redis.multi().lrange(queue, 0, last).ltrim(queue, limit, -1).exec(function (error, out) {
+                error ? reject(error) : resolve(out);
+            });
+        });
+        return items;
+    }
+    // redis@4
+    const [items] = await redis.multi().LRANGE(queue, 0, last).LTRIM(queue, limit, -1).exec();
     return items;
 }
 

package/src/redis_lshift.test.js

@@ -0,0 +1,57 @@
+const assert = require('assert');
+const redis_lshift = require('./redis_lshift');
+
+const REDIS_HOST = '127.0.0.1';
+const REDIS_PORT = 6379;
+const REDIS_AUTH = null;
+const REDIS_QUEUE = 'TESTING';
+
+describe('redis_lshift', function () {
+    it('should work with redis@1', async function () {
+        await test_1_2_3(require('redis-v1'));
+    });
+    it('should work with redis@2', async function () {
+        await test_1_2_3(require('redis-v2'));
+    });
+    it('should work with redis@3', async function () {
+        await test_1_2_3(require('redis-v3'));
+    });
+    it('should work with redis@4', async function () {
+        await test_4(require('redis-v4'));
+    });
+});
+
+async function test_1_2_3(redis)
+{
+    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
+    try {
+        const expected = 'aa,bb,cc,dd,ee'.split(',');
+        await new Promise(function (resolve, reject) {
+            r.del(REDIS_QUEUE, (e,v) => e ? reject(e) : resolve(v));
+        });
+        await new Promise(function (resolve, reject) {
+            r.rpush(REDIS_QUEUE, ...expected, (e,v) => e ? reject(e) : resolve(v));
+        });
+        const actual = await redis_lshift(r, REDIS_QUEUE, expected.length);
+        await assert.deepStrictEqual(actual, expected);
+    }
+    finally {
+        await r.quit();
+    }
+}
+
+async function test_4(redis)
+{
+    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
+    await r.connect();
+    try {
+        const expected = 'aa,bb,cc,dd,ee'.split(',');
+        await r.DEL(REDIS_QUEUE);
+        await r.RPUSH(REDIS_QUEUE, expected);
+        const actual = await redis_lshift(r, REDIS_QUEUE, expected.length);
+        await assert.deepStrictEqual(actual, expected);
+    }
+    finally {
+        await r.quit();
+    }
+}

package/src/redis_zshift.js

@@ -1,8 +1,16 @@
 async function redis_zshift(redis, queue, limit = 1)
 {
     const last = limit - 1;
-    // noinspection JSUnresolvedFunction
-    const [items] = await redis.multi().zrange(queue, 0, last).zremrangebyrank(queue, 0, last).exec_p();
+    if (redis.zrange) {
+        const [items] = await new Promise(function (resolve, reject) {
+            redis.multi().zrange(queue, 0, last).zremrangebyrank(queue, 0, last).exec(function (error, out) {
+                error ? reject(error) : resolve(out);
+            });
+        });
+        return items;
+    }
+    // redis@4
+    const [items] = await redis.multi().ZRANGE(queue, 0, last).ZREMRANGEBYRANK(queue, 0, last).exec();
     return items;
 }
 

package/src/redis_zshift.test.js

@@ -0,0 +1,58 @@
+const assert = require('assert');
+const redis_zshift = require('./redis_zshift');
+
+const REDIS_HOST = '127.0.0.1';
+const REDIS_PORT = 6379;
+const REDIS_AUTH = null;
+const REDIS_QUEUE = 'TESTING';
+
+describe('redis_zshift', function () {
+    it('should work with redis@1', async function () {
+        await test_1_2_3(require('redis-v1'));
+    });
+    it('should work with redis@2', async function () {
+        await test_1_2_3(require('redis-v2'));
+    });
+    it('should work with redis@3', async function () {
+        await test_1_2_3(require('redis-v3'));
+    });
+    it('should work with redis@4', async function () {
+        await test_4(require('redis-v4'));
+    });
+});
+
+async function test_1_2_3(redis)
+{
+    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
+    try {
+        const expected = 'aa,bb,cc,dd,ee'.split(',');
+        await new Promise(function (resolve, reject) {
+            r.del(REDIS_QUEUE, (e,v) => e ? reject(e) : resolve(v));
+        });
+        await new Promise(function (resolve, reject) {
+            const args = [REDIS_QUEUE, ...expected.map((v,i) => [i,v]).flat()];
+            r.zadd(args, (e,v) => e ? reject(e) : resolve(v));
+        });
+        const actual = await redis_zshift(r, REDIS_QUEUE, expected.length);
+        await assert.deepStrictEqual(actual, expected);
+    }
+    finally {
+        await r.quit();
+    }
+}
+
+async function test_4(redis)
+{
+    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
+    await r.connect();
+    try {
+        const expected = 'aa,bb,cc,dd,ee'.split(',');
+        await r.DEL(REDIS_QUEUE);
+        await r.ZADD(REDIS_QUEUE, expected.map((value,i) => ({score: i, value})));
+        const actual = await redis_zshift(r, REDIS_QUEUE, 5);
+        await assert.deepStrictEqual(actual, expected);
+    }
+    finally {
+        await r.quit();
+    }
+}