@shopware-ag/dive 1.18.5-beta.2 → 1.18.5

package/src/module/Module.ts

@@ -0,0 +1,45 @@
+export class DIVEModule<T> {
+    constructor(
+        private _path: string,
+        private _ctor: string,
+    ) {}
+
+    private _promise: Promise<T> | null = null;
+    private _instance: T | null = null;
+
+    public async get(): Promise<T> {
+        // if we already have an instance, return it
+        if (this._instance) {
+            return Promise.resolve(this._instance);
+        }
+
+        // if we already have a loading process ongoing, return the already created promise
+        if (this._promise) {
+            return this._promise;
+        }
+
+        // if we don't have a promise yet, it means that we are not already loading the module
+        this._promise = (async () => {
+            const module = await import(this._path);
+
+            const ModuleConstructor = module[this._ctor];
+
+            if (!ModuleConstructor) {
+                throw new Error(
+                    `DIVE: Module class ${this._ctor} not found in ${this._path}`,
+                );
+            }
+
+            if (typeof ModuleConstructor !== 'function') {
+                throw new Error(
+                    `DIVE: Module at ${this._path} does not export a valid constructor (${this._ctor} wanted)`,
+                );
+            }
+
+            this._instance = new ModuleConstructor() as T;
+            return this._instance;
+        })();
+
+        return this._promise;
+    }
+}

package/src/module/__test__/Module.test.ts

@@ -0,0 +1,54 @@
+import { DIVEModule } from '../Module';
+
+jest.mock('/mock/path', () => mockModule, { virtual: true });
+
+const mockModule: Record<string, any> = {};
+
+describe('dive/module/DIVEModule', () => {
+    beforeEach(() => {
+        // Reset the mock module before each test
+        Object.keys(mockModule).forEach((key) => delete mockModule[key]);
+    });
+
+    it('should return the same instance on multiple calls to get()', async () => {
+        mockModule.TestClass = class TestClass {};
+        const diveModule = new DIVEModule('/mock/path', 'TestClass');
+
+        const instance1 = await diveModule.get();
+        const instance2 = await diveModule.get();
+
+        expect(instance1).toBe(instance2);
+    });
+
+    it('should throw an error if the constructor is not found', async () => {
+        const diveModule = new DIVEModule('/mock/path', 'NonExistentClass');
+
+        await expect(diveModule.get()).rejects.toThrow(
+            'DIVE: Module class NonExistentClass not found in /mock/path',
+        );
+    });
+
+    it('should throw an error if the constructor is not a function', async () => {
+        mockModule.InvalidClass = {};
+        const diveModule = new DIVEModule('/mock/path', 'InvalidClass');
+
+        await expect(diveModule.get()).rejects.toThrow(
+            'DIVE: Module at /mock/path does not export a valid constructor (InvalidClass wanted)',
+        );
+    });
+
+    it('should only load the module once even with concurrent calls to get()', async () => {
+        mockModule.TestClass = class TestClass {};
+        const diveModule = new DIVEModule('/mock/path', 'TestClass');
+
+        const [
+            instance1,
+            instance2,
+        ] = await Promise.all([
+            diveModule.get(),
+            diveModule.get(),
+        ]);
+
+        expect(instance1).toBe(instance2);
+    });
+});