@daiso-tech/core 0.7.0 → 0.8.0

package/dist/esm/event-bus/implementations/event-bus/event-bus.js

@@ -0,0 +1,100 @@
+import { LazyPromise } from "../../../utilities/_module";
+import { DispatchEventBusError, RemoveListenerEventBusError, AddListenerEventBusError, } from "../../../event-bus/contracts/_module";
+import { WithNamespaceEventBusAdapter } from "../../../event-bus/implementations/event-bus/with-namespace-event-bus-adapter";
+import { WithValidationEventBusAdapter } from "../../../event-bus/implementations/event-bus/with-validation-event-bus-adapter";
+import { isArrayEmpty } from "../../../_shared/utilities";
+export class EventBus {
+    eventBusAdapter;
+    namespace_;
+    validator;
+    constructor(eventBusAdapter, settings = {}) {
+        const { rootNamespace: namespace = "", validator = (value) => value, } = settings;
+        this.namespace_ = namespace;
+        this.validator = validator;
+        this.eventBusAdapter = new WithNamespaceEventBusAdapter(new WithValidationEventBusAdapter(eventBusAdapter, this.validator), this.namespace_);
+    }
+    withNamespace(namespace) {
+        return new EventBus(this.eventBusAdapter, {
+            validator: this.validator,
+            rootNamespace: `${this.namespace_}${namespace}`,
+        });
+    }
+    getNamespace() {
+        return this.namespace_;
+    }
+    addListener(event, listener) {
+        return new LazyPromise(async () => {
+            try {
+                await this.eventBusAdapter.addListener(event, listener);
+            }
+            catch (error) {
+                throw new AddListenerEventBusError(`A listener with name of "${listener.name}" could not added for "${event}" event`, error);
+            }
+        });
+    }
+    addListenerMany(events, listener) {
+        return new LazyPromise(async () => {
+            if (isArrayEmpty(events)) {
+                return;
+            }
+            const promises = [];
+            for (const event of events) {
+                promises.push(this.addListener(event, listener));
+            }
+            await Promise.all(promises);
+        });
+    }
+    removeListener(event, listener) {
+        return new LazyPromise(async () => {
+            try {
+                await this.eventBusAdapter.removeListener(event, listener);
+            }
+            catch (error) {
+                throw new RemoveListenerEventBusError(`A listener with name of "${listener.name}" could not removed of "${event}" event`, error);
+            }
+        });
+    }
+    removeListenerMany(events, listener) {
+        return new LazyPromise(async () => {
+            if (isArrayEmpty(events)) {
+                return;
+            }
+            const promises = [];
+            for (const event of events) {
+                promises.push(this.removeListener(event, listener));
+            }
+            await Promise.all(promises);
+        });
+    }
+    subscribe(event, listener) {
+        return this.subscribeMany([event], listener);
+    }
+    subscribeMany(events, listener) {
+        return new LazyPromise(async () => {
+            await this.addListenerMany(events, listener);
+            const unsubscribe = () => {
+                return new LazyPromise(async () => {
+                    await this.removeListenerMany(events, listener);
+                });
+            };
+            return unsubscribe;
+        });
+    }
+    dispatch(events) {
+        return new LazyPromise(async () => {
+            if (!Array.isArray(events)) {
+                events = [events];
+            }
+            if (isArrayEmpty(events)) {
+                return;
+            }
+            try {
+                await this.eventBusAdapter.dispatch(events);
+            }
+            catch (error) {
+                throw new DispatchEventBusError(`Events "${events.map((event) => event.type).join(", ")}" could not be dispatched`, error);
+            }
+        });
+    }
+}
+//# sourceMappingURL=event-bus.js.map

package/dist/esm/event-bus/implementations/event-bus/event-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/event-bus/event-bus.ts"],"names":[],"mappings":"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"}

package/dist/esm/event-bus/implementations/event-bus/with-namespace-event-bus-adapter.js

@@ -0,0 +1,37 @@
+export class WithNamespaceEventBusAdapter {
+    eventBusAdapter;
+    namespace;
+    listenerMap = new Map();
+    constructor(eventBusAdapter, namespace) {
+        this.eventBusAdapter = eventBusAdapter;
+        this.namespace = namespace;
+    }
+    async addListener(event, listener) {
+        let wrappedListener = this.listenerMap.get(listener);
+        if (wrappedListener === undefined) {
+            wrappedListener = async (eventObj) => {
+                await listener({
+                    ...eventObj,
+                    type: eventObj.type.slice(this.namespace.length),
+                });
+            };
+            this.listenerMap.set(listener, wrappedListener);
+        }
+        await this.eventBusAdapter.addListener(`${this.namespace}${event}`, wrappedListener);
+    }
+    async removeListener(event, listener) {
+        const wrappedListener = this.listenerMap.get(listener);
+        if (wrappedListener === undefined) {
+            return;
+        }
+        await this.eventBusAdapter.removeListener(`${this.namespace}${event}`, wrappedListener);
+        this.listenerMap.delete(listener);
+    }
+    async dispatch(events) {
+        await this.eventBusAdapter.dispatch(events.map((event) => ({
+            ...event,
+            type: `${this.namespace}${event.type}`,
+        })));
+    }
+}
+//# sourceMappingURL=with-namespace-event-bus-adapter.js.map

package/dist/esm/event-bus/implementations/event-bus/with-namespace-event-bus-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-namespace-event-bus-adapter.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/event-bus/with-namespace-event-bus-adapter.ts"],"names":[],"mappings":"AAaA,MAAM,OAAO,4BAA4B;IAOhB;IACA;IAPJ,WAAW,GAAG,IAAI,GAAG,EAGnC,CAAC;IAEJ,YACqB,eAAiC,EACjC,SAAiB;QADjB,oBAAe,GAAf,eAAe,CAAkB;QACjC,cAAS,GAAT,SAAS,CAAQ;IACnC,CAAC;IAEJ,KAAK,CAAC,WAAW,CACb,KAAa,EACb,QAA8B;QAE9B,IAAI,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACrD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;YAChC,eAAe,GAAG,KAAK,EAAE,QAAoB,EAAE,EAAE;gBAC7C,MAAM,QAAQ,CAAC;oBACX,GAAG,QAAQ;oBACX,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;iBACnD,CAAC,CAAC;YACP,CAAC,CAAC;YACF,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,IAAI,CAAC,eAAe,CAAC,WAAW,CAClC,GAAG,IAAI,CAAC,SAAS,GAAG,KAAK,EAAE,EAC3B,eAAe,CAClB,CAAC;IACN,CAAC;IAED,KAAK,CAAC,cAAc,CAChB,KAAa,EACb,QAA8B;QAE9B,MAAM,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACvD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;YAChC,OAAO;QACX,CAAC;QAED,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CACrC,GAAG,IAAI,CAAC,SAAS,GAAG,KAAK,EAAE,EAC3B,eAAe,CAClB,CAAC;QACF,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,MAAoB;QAC/B,MAAM,IAAI,CAAC,eAAe,CAAC,QAAQ,CAC/B,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACnB,GAAG,KAAK;YACR,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,IAAI,EAAE;SACzC,CAAC,CAAC,CACN,CAAC;IACN,CAAC;CACJ"}

package/dist/esm/event-bus/implementations/event-bus/with-validation-event-bus-adapter.js

@@ -0,0 +1,31 @@
+export class WithValidationEventBusAdapter {
+    eventBusAdapter;
+    validator;
+    listenerMap = new Map();
+    constructor(eventBusAdapter, validator) {
+        this.eventBusAdapter = eventBusAdapter;
+        this.validator = validator;
+    }
+    async addListener(event, listener) {
+        let wrappedListener = this.listenerMap.get(listener);
+        if (wrappedListener === undefined) {
+            wrappedListener = async (event) => {
+                await listener(this.validator(event));
+            };
+            this.listenerMap.set(listener, wrappedListener);
+        }
+        await this.eventBusAdapter.addListener(event, wrappedListener);
+    }
+    async removeListener(event, listener) {
+        const wrappedListener = this.listenerMap.get(listener);
+        if (wrappedListener === undefined) {
+            return;
+        }
+        await this.eventBusAdapter.removeListener(event, wrappedListener);
+        this.listenerMap.delete(listener);
+    }
+    async dispatch(events) {
+        await this.eventBusAdapter.dispatch(events.map(this.validator));
+    }
+}
+//# sourceMappingURL=with-validation-event-bus-adapter.js.map

package/dist/esm/event-bus/implementations/event-bus/with-validation-event-bus-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-validation-event-bus-adapter.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/event-bus/with-validation-event-bus-adapter.ts"],"names":[],"mappings":"AAcA,MAAM,OAAO,6BAA6B;IAOjB;IACA;IAPJ,WAAW,GAAG,IAAI,GAAG,EAGnC,CAAC;IAEJ,YACqB,eAAiC,EACjC,SAAgC;QADhC,oBAAe,GAAf,eAAe,CAAkB;QACjC,cAAS,GAAT,SAAS,CAAuB;IAClD,CAAC;IAEJ,KAAK,CAAC,WAAW,CACb,KAAa,EACb,QAA8B;QAE9B,IAAI,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACrD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;YAChC,eAAe,GAAG,KAAK,EAAE,KAAiB,EAAE,EAAE;gBAC1C,MAAM,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YAC1C,CAAC,CAAC;YACF,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;IACnE,CAAC;IAED,KAAK,CAAC,cAAc,CAChB,KAAa,EACb,QAA8B;QAE9B,MAAM,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACvD,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;YAChC,OAAO;QACX,CAAC;QAED,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAClE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,MAAoB;QAC/B,MAAM,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IACpE,CAAC;CACJ"}

package/dist/esm/event-bus/implementations/memory-event-bus-adapter/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../event-bus/implementations/memory-event-bus-adapter/_module";
+//# sourceMappingURL=_module.js.map

package/dist/esm/event-bus/implementations/memory-event-bus-adapter/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/memory-event-bus-adapter/_module.ts"],"names":[],"mappings":"AAAA,cAAc,8DAA8D,CAAC"}

package/dist/esm/event-bus/implementations/memory-event-bus-adapter/memory-event-bus-adapter.js

@@ -0,0 +1,19 @@
+import { EventEmitter } from "node:events";
+export class MemoryEventBusAdapter {
+    eventEmiter;
+    constructor(eventEmiter = new EventEmitter()) {
+        this.eventEmiter = eventEmiter;
+    }
+    async addListener(event, listener) {
+        this.eventEmiter.addListener(event, listener);
+    }
+    async removeListener(event, listener) {
+        this.eventEmiter.removeListener(event, listener);
+    }
+    async dispatch(events) {
+        for (const event of events) {
+            this.eventEmiter.emit(event.type, event);
+        }
+    }
+}
+//# sourceMappingURL=memory-event-bus-adapter.js.map

package/dist/esm/event-bus/implementations/memory-event-bus-adapter/memory-event-bus-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-event-bus-adapter.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/memory-event-bus-adapter/memory-event-bus-adapter.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,MAAM,OAAO,qBAAqB;IACD;IAA7B,YAA6B,cAAc,IAAI,YAAY,EAAE;QAAhC,gBAAW,GAAX,WAAW,CAAqB;IAAG,CAAC;IAGjE,KAAK,CAAC,WAAW,CACb,KAAa,EACb,QAA8B;QAG9B,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;IAGD,KAAK,CAAC,cAAc,CAChB,KAAa,EACb,QAA8B;QAG9B,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACrD,CAAC;IAGD,KAAK,CAAC,QAAQ,CAAC,MAAoB;QAC/B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YACzB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC7C,CAAC;IACL,CAAC;CACJ"}

package/dist/esm/event-bus/implementations/no-op-event-bus-adapter/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter";
+//# sourceMappingURL=_module.js.map

package/dist/esm/event-bus/implementations/no-op-event-bus-adapter/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/no-op-event-bus-adapter/_module.ts"],"names":[],"mappings":"AAAA,cAAc,6EAA6E,CAAC"}

package/dist/esm/event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter.js

@@ -0,0 +1,12 @@
+export class NoOpEventBusAdapter {
+    addListener(_event, _listener) {
+        return Promise.resolve();
+    }
+    removeListener(_event, _listener) {
+        return Promise.resolve();
+    }
+    dispatch(_events) {
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=no-op-event-bus-adapter.js.map

package/dist/esm/event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-op-event-bus-adapter.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter.ts"],"names":[],"mappings":"AAWA,MAAM,OAAO,mBAAmB;IAC5B,WAAW,CACP,MAAc,EACd,SAA+B;QAE/B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED,cAAc,CACV,MAAc,EACd,SAA+B;QAE/B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED,QAAQ,CAAC,OAAqB;QAC1B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;CACJ"}

package/dist/esm/event-bus/implementations/redis-event-bus-adapter/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../event-bus/implementations/memory-event-bus-adapter/_module";
+//# sourceMappingURL=_module.js.map

package/dist/esm/event-bus/implementations/redis-event-bus-adapter/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/redis-event-bus-adapter/_module.ts"],"names":[],"mappings":"AAAA,cAAc,8DAA8D,CAAC"}

package/dist/esm/event-bus/implementations/redis-event-bus-adapter/redis-event-bus-adapter.js

@@ -0,0 +1,41 @@
+import { RedisSerializer, SuperJsonSerializer, } from "../../../serializer/implementations/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import { EventEmitter } from "node:events";
+export class RedisEventBusAdapter {
+    serializer;
+    dispatcherClient;
+    listenerClient;
+    eventEmitter = new EventEmitter();
+    constructor({ dispatcherClient, listenerClient, serializer = new SuperJsonSerializer(), }) {
+        this.dispatcherClient = dispatcherClient;
+        this.listenerClient = listenerClient;
+        this.serializer = new RedisSerializer(serializer);
+    }
+    redisListener = async (channel, message) => {
+        this.eventEmitter.emit(channel, await this.serializer.deserialize(message));
+    };
+    async addListener(event, listener) {
+        await this.listenerClient.subscribe(event);
+        this.listenerClient.on("message", this.redisListener);
+        this.eventEmitter.on(event, listener);
+    }
+    async removeListener(event, listener) {
+        await this.listenerClient.unsubscribe(event);
+        this.eventEmitter.off(event, listener);
+        let totalListenerCount = 0;
+        for (const event of this.eventEmitter.eventNames()) {
+            totalListenerCount += this.eventEmitter.listenerCount(event);
+        }
+        if (totalListenerCount === 0) {
+            this.listenerClient.off("message", this.redisListener);
+        }
+    }
+    async dispatch(events) {
+        const promises = [];
+        for (const event of events) {
+            promises.push(new LazyPromise(async () => this.dispatcherClient.publish(event.type, await this.serializer.serialize(event))));
+        }
+        await Promise.all(promises);
+    }
+}
+//# sourceMappingURL=redis-event-bus-adapter.js.map

package/dist/esm/event-bus/implementations/redis-event-bus-adapter/redis-event-bus-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-event-bus-adapter.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/redis-event-bus-adapter/redis-event-bus-adapter.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,eAAe,EACf,mBAAmB,GACtB,MAAM,sCAAsC,CAAC;AAO9C,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAc3C,MAAM,OAAO,oBAAoB;IACZ,UAAU,CAAsB;IAChC,gBAAgB,CAAQ;IACxB,cAAc,CAAQ;IACtB,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;IAEnD,YAAY,EACR,gBAAgB,EAChB,cAAc,EACd,UAAU,GAAG,IAAI,mBAAmB,EAAE,GACX;QAC3B,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QACzC,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,UAAU,GAAG,IAAI,eAAe,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IAEO,aAAa,GAAG,KAAK,EAAE,OAAe,EAAE,OAAe,EAAE,EAAE;QAC/D,IAAI,CAAC,YAAY,CAAC,IAAI,CAClB,OAAO,EACP,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,OAAO,CAAC,CAC7C,CAAC;IACN,CAAC,CAAC;IAEF,KAAK,CAAC,WAAW,CACb,KAAa,EACb,QAA8B;QAE9B,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAG3C,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAGtD,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,cAAc,CAChB,KAAa,EACb,QAA8B;QAE9B,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAE7C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAEvC,IAAI,kBAAkB,GAAG,CAAC,CAAC;QAC3B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,CAAC;YACjD,kBAAkB,IAAI,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACjE,CAAC;QAED,IAAI,kBAAkB,KAAK,CAAC,EAAE,CAAC;YAE3B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC3D,CAAC;IACL,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,MAAoB;QAC/B,MAAM,QAAQ,GAA0B,EAAE,CAAC;QAC3C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YACzB,QAAQ,CAAC,IAAI,CACT,IAAI,WAAW,CAAC,KAAK,IAAI,EAAE,CACvB,IAAI,CAAC,gBAAgB,CAAC,OAAO,CACzB,KAAK,CAAC,IAAI,EACV,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CACzC,CACJ,CACJ,CAAC;QACN,CAAC;QACD,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;CACJ"}

package/dist/esm/storage/contracts/_module.js

@@ -1,4 +1,6 @@
 export * from "../../storage/contracts/_shared";
 export * from "../../storage/contracts/storage.contract";
 export * from "../../storage/contracts/storage-adapter.contract";
+export * from "../../storage/contracts/storage-events.contract";
+export * from "../../storage/contracts/storage-manager.contract";
 //# sourceMappingURL=_module.js.map

package/dist/esm/storage/contracts/_module.js.map

@@ -1 +1 @@
-{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/storage/contracts/_module.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,8CAA8C,CAAC"}
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/storage/contracts/_module.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC"}

package/dist/esm/storage/contracts/storage-events.contract.js

@@ -0,0 +1,11 @@
+export const STORAGE_EVENTS = {
+    KEYS_FOUND: "keys_found",
+    KEYS_NOT_FOUND: "keys_not_found",
+    KEYS_ADDED: "keys_added",
+    KEYS_UPDATED: "keys_updated",
+    KEYS_REMOVED: "keys_removed",
+    KEYS_CLEARED: "keys_cleared",
+    KEY_INCREMENTED: "key_incremented",
+    KEY_DECREMENTED: "key_decremented",
+};
+//# sourceMappingURL=storage-events.contract.js.map

package/dist/esm/storage/contracts/storage-events.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-events.contract.js","sourceRoot":"","sources":["../../../../src/storage/contracts/storage-events.contract.ts"],"names":[],"mappings":"AAYA,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,UAAU,EAAE,YAAY;IACxB,cAAc,EAAE,gBAAgB;IAChC,UAAU,EAAE,YAAY;IACxB,YAAY,EAAE,cAAc;IAC5B,YAAY,EAAE,cAAc;IAC5B,YAAY,EAAE,cAAc;IAC5B,eAAe,EAAE,iBAAiB;IAClC,eAAe,EAAE,iBAAiB;CAC5B,CAAC"}

package/dist/esm/storage/contracts/storage-manager.contract.js

@@ -0,0 +1 @@
+//# sourceMappingURL=storage-manager.contract.js.map

package/dist/esm/storage/contracts/storage-manager.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-manager.contract.js","sourceRoot":"","sources":["../../../../src/storage/contracts/storage-manager.contract.ts"],"names":[],"mappings":""}

package/dist/esm/storage/implementations/_shared/test-utilities/storage-adapter.test-suite.js

@@ -1,7 +1,295 @@
-import { storageAdapterValueTestSuite } from "../../../../storage/implementations/_shared/test-utilities/storage-adapter-value.test-suite";
-import { storageAdapterApiTestSuite } from "../../../../storage/implementations/_shared/test-utilities/storage-adapter-api.test-suite";
+import { TypeStorageError, } from "../../../../storage/contracts/_module";
 export function storageTestSuite(settings) {
-    storageAdapterApiTestSuite(settings);
-    storageAdapterValueTestSuite(settings);
+    const { expect, test, createAdapter, describe, beforeEach } = settings;
+    let storageAdapter;
+    beforeEach(async () => {
+        storageAdapter = await createAdapter();
+    });
+    describe("method: getMany", () => {
+        test("Should return only values when all keys exists", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: 1,
+                b: 1,
+            });
+        });
+        test("Should return only null when all keys doesnt exists", async () => {
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: null,
+                b: null,
+            });
+        });
+        test("Should return values and null when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: 1,
+                b: null,
+            });
+        });
+    });
+    describe("method: addMany", () => {
+        test("Should return only true when all keys doesnt exists", async () => {
+            expect(await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            })).toEqual({
+                a: true,
+                b: true,
+            });
+        });
+        test("Should persist values when all keys doesnt exist", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: 1,
+                b: 1,
+            });
+        });
+        test("Should return only false when all keys exists", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            expect(await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            })).toEqual({
+                a: false,
+                b: false,
+            });
+        });
+        test("Should not persist values when key exist", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            await storageAdapter.addMany({
+                a: 2,
+                b: 2,
+            });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: 1,
+                b: 1,
+            });
+        });
+        test("Should return true and false when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            expect(await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            })).toEqual({
+                a: false,
+                b: true,
+            });
+        });
+        test("Should persist and not persist values when some keys exists", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+            });
+            await storageAdapter.addMany({
+                a: 2,
+                b: 2,
+            });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: 1,
+                b: 2,
+            });
+        });
+    });
+    describe("method: updateMany", () => {
+        test("Should return only true when all keys exists", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            expect(await storageAdapter.updateMany({ a: -1, b: -1 })).toEqual({
+                a: true,
+                b: true,
+            });
+        });
+        test("Should persist values when all keys exist", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            await storageAdapter.updateMany({ a: -1, b: -1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: -1,
+                b: -1,
+            });
+        });
+        test("Should return only false when all keys doesnt exists", async () => {
+            expect(await storageAdapter.updateMany({ a: -1, b: -1 })).toEqual({
+                a: false,
+                b: false,
+            });
+        });
+        test("Should not persist values when all keys doesnt exist", async () => {
+            await storageAdapter.updateMany({ a: -1, b: -1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: null,
+                b: null,
+            });
+        });
+        test("Should return true and false when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            expect(await storageAdapter.updateMany({ a: -1, b: -1 })).toEqual({
+                a: true,
+                b: false,
+            });
+        });
+        test("Should persist and not persist values when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            await storageAdapter.updateMany({ a: -1, b: -1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: -1,
+                b: null,
+            });
+        });
+    });
+    describe("method: putMany", () => {
+        test("Should return only true when all keys exists", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            expect(await storageAdapter.putMany({ a: -1, b: -1 })).toEqual({
+                a: true,
+                b: true,
+            });
+        });
+        test("Should persist values when all keys exist", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            await storageAdapter.putMany({ a: -1, b: -1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: -1,
+                b: -1,
+            });
+        });
+        test("Should return only false when all keys doesnt exists", async () => {
+            expect(await storageAdapter.putMany({ a: -1, b: -1 })).toEqual({
+                a: false,
+                b: false,
+            });
+        });
+        test("Should persist values when all keys doesnt exist", async () => {
+            await storageAdapter.putMany({ a: -1, b: -1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: -1,
+                b: -1,
+            });
+        });
+        test("Should return true and false when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            expect(await storageAdapter.putMany({ a: -1, b: -1 })).toEqual({
+                a: true,
+                b: false,
+            });
+        });
+        test("Should persist all values when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            await storageAdapter.putMany({ a: -1, b: -1 });
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: -1,
+                b: -1,
+            });
+        });
+    });
+    describe("method: removeMany", () => {
+        test("Should return only true when all keys exists", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            expect(await storageAdapter.removeMany(["a", "b"])).toEqual({
+                a: true,
+                b: true,
+            });
+        });
+        test("Should persist values when all keys exist", async () => {
+            await storageAdapter.addMany({
+                a: 1,
+                b: 1,
+            });
+            await storageAdapter.removeMany(["a", "b"]);
+            expect(await storageAdapter.getMany(["a", "b"])).toEqual({
+                a: null,
+                b: null,
+            });
+        });
+        test("Should return only false when all keys doesnt exists", async () => {
+            expect(await storageAdapter.removeMany(["a", "b"])).toEqual({
+                a: false,
+                b: false,
+            });
+        });
+        test("Should return true and false when some keys exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            expect(await storageAdapter.removeMany(["a", "b"])).toEqual({
+                a: true,
+                b: false,
+            });
+        });
+    });
+    describe("method: increment", () => {
+        test("Should return true when key exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            expect(await storageAdapter.increment("a", 1)).toBe(true);
+        });
+        test("Should persist increment when key exists", async () => {
+            await storageAdapter.addMany({ a: 1 });
+            await storageAdapter.increment("a", 1);
+            expect(await storageAdapter.getMany(["a"])).toEqual({ a: 2 });
+        });
+        test("Should return false when key doesnt exists", async () => {
+            expect(await storageAdapter.increment("a", 1)).toBe(false);
+        });
+        test("Should not persist increment when key doesnt exists", async () => {
+            await storageAdapter.increment("a", 1);
+            expect(await storageAdapter.getMany(["a"])).toEqual({
+                a: null,
+            });
+        });
+        test("Should throw TypeStorageError key value is not number type", async () => {
+            await storageAdapter.addMany({ a: "str" });
+            await expect(storageAdapter.increment("a", 1)).rejects.toBeInstanceOf(TypeStorageError);
+        });
+    });
+    describe("method: clear", () => {
+        test("Should remove all keys", async () => {
+            await storageAdapter.addMany({
+                "@a/a": 1,
+                "@a/b": 2,
+                "@a/c": 3,
+                "@b/d": 4,
+                "@b/e": 5,
+                "@b/f": 6,
+            });
+            await storageAdapter.clear("@a/");
+            expect(await storageAdapter.getMany([
+                "@a/a",
+                "@a/b",
+                "@a/c",
+                "@b/d",
+                "@b/e",
+                "@b/f",
+            ])).toEqual({
+                "@a/a": null,
+                "@a/b": null,
+                "@a/c": null,
+                "@b/d": 4,
+                "@b/e": 5,
+                "@b/f": 6,
+            });
+        });
+    });
 }
 //# sourceMappingURL=storage-adapter.test-suite.js.map