Add sequentialize to prevent parralel loading of cipher keys (#7)

* Add sequentialize to prevent parralel loading of cipher keys

Massively improves start up performance of extensions

* Add tests for sequentialize

* Fix sequentialize as it was caching calls for all instances together

* Add sequentialize to the functions that have internal caches

* Adding sequentialize to getOrgKeys makes big performance difference

* Update cipher.service.ts

* Update collection.service.ts

* Update folder.service.ts

spec/common/misc/sequentialize.spec.ts

@@ -0,0 +1,141 @@
+import { sequentialize } from '../../../src/misc/sequentialize';
+
+describe('sequentialize decorator', () => {
+    it('should call the function once', async () => {
+        const foo = new Foo();
+        const promises = [];
+        for (let i = 0; i < 10; i++) {
+            promises.push(foo.bar(1));
+        }
+        await Promise.all(promises);
+
+        expect(foo.calls).toBe(1);
+    });
+
+    it('should call the function once for each instance of the object', async () => {
+        const foo = new Foo();
+        const foo2 = new Foo();
+        const promises = [];
+        for (let i = 0; i < 10; i++) {
+            promises.push(foo.bar(1));
+            promises.push(foo2.bar(1));
+        }
+        await Promise.all(promises);
+
+        expect(foo.calls).toBe(1);
+        expect(foo2.calls).toBe(1);
+    });
+
+    it('should call the function once with key function', async () => {
+        const foo = new Foo();
+        const promises = [];
+        for (let i = 0; i < 10; i++) {
+            promises.push(foo.baz(1));
+        }
+        await Promise.all(promises);
+
+        expect(foo.calls).toBe(1);
+    });
+
+    it('should call the function again when already resolved', async () => {
+        const foo = new Foo();
+        await foo.bar(1);
+        expect(foo.calls).toBe(1);
+        await foo.bar(1);
+        expect(foo.calls).toBe(2);
+    });
+
+    it('should call the function again when already resolved with a key function', async () => {
+        const foo = new Foo();
+        await foo.baz(1);
+        expect(foo.calls).toBe(1);
+        await foo.baz(1);
+        expect(foo.calls).toBe(2);
+    });
+
+    it('should call the function for each argument', async () => {
+        const foo = new Foo();
+        await Promise.all([
+            foo.bar(1),
+            foo.bar(1),
+            foo.bar(2),
+            foo.bar(2),
+            foo.bar(3),
+            foo.bar(3),
+        ]);
+        expect(foo.calls).toBe(3);
+    });
+
+    it('should call the function for each argument with key function', async () => {
+        const foo = new Foo();
+        await Promise.all([
+            foo.baz(1),
+            foo.baz(1),
+            foo.baz(2),
+            foo.baz(2),
+            foo.baz(3),
+            foo.baz(3),
+        ]);
+        expect(foo.calls).toBe(3);
+    });
+
+    it('should return correct result for each call', async () => {
+        const foo = new Foo();
+        const allRes = [];
+
+        await Promise.all([
+            foo.bar(1).then((res) => allRes.push(res)),
+            foo.bar(1).then((res) => allRes.push(res)),
+            foo.bar(2).then((res) => allRes.push(res)),
+            foo.bar(2).then((res) => allRes.push(res)),
+            foo.bar(3).then((res) => allRes.push(res)),
+            foo.bar(3).then((res) => allRes.push(res)),
+        ]);
+        expect(foo.calls).toBe(3);
+        expect(allRes.length).toBe(6);
+        allRes.sort();
+        expect(allRes).toEqual([2, 2, 4, 4, 6, 6]);
+    });
+
+    it('should return correct result for each call with key function', async () => {
+        const foo = new Foo();
+        const allRes = [];
+
+        await Promise.all([
+            foo.baz(1).then((res) => allRes.push(res)),
+            foo.baz(1).then((res) => allRes.push(res)),
+            foo.baz(2).then((res) => allRes.push(res)),
+            foo.baz(2).then((res) => allRes.push(res)),
+            foo.baz(3).then((res) => allRes.push(res)),
+            foo.baz(3).then((res) => allRes.push(res)),
+        ]);
+        expect(foo.calls).toBe(3);
+        expect(allRes.length).toBe(6);
+        allRes.sort();
+        expect(allRes).toEqual([3, 3, 6, 6, 9, 9]);
+    });
+});
+
+class Foo {
+    calls = 0;
+
+    @sequentialize()
+    bar(a) {
+        this.calls++;
+        return new Promise((res) => {
+            setTimeout(() => {
+                res(a * 2);
+            }, Math.random() * 100);
+        });
+    }
+
+    @sequentialize((args) => args[0])
+    baz(a) {
+        this.calls++;
+        return new Promise((res) => {
+            setTimeout(() => {
+                res(a * 3);
+            }, Math.random() * 100);
+        });
+    }
+}