@yuno-payments/sdk-event-log 0.3.0-beta.10 → 0.3.0-beta.11

package/dist/cjs/index.test.js

@@ -10,8 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
-const database_1 = require("./database");
-const PUBLIC_API_KEY = 'staging_gAAAAABj-NC2WEf3XA4lHnN6RfGbjETf6qL27jlU7c1tm01ERV-Y-E6ddee1QPyV_CA8cxjVlGy-qDNA2-mqa9msQlTJit-Fmbvv6f2AZdfbFd_CUo1stvixnF4_8MzM_IYVWYz7KK86VfEBvxNpjRCyp7BDef-QzrT1-yqa8HAYTuA1GU3Hjjo=';
+const types_1 = require("./types");
+const node_1 = require("msw/node");
+const msw_1 = require("msw");
 const eventArgs = {
     source: 'test',
     event: 'testEvent',
@@ -23,91 +24,152 @@ const logArgs = {
     url: '',
     method: '',
     country: '',
-    original_created_at: new Date().toISOString()
+    original_created_at: new Date().toISOString(),
 };
+const publicApiKey = 'prod_1';
+let mockInterceptRequest = jest.fn();
+const server = (0, node_1.setupServer)(
+// Describe the requests to mock.
+msw_1.rest.post('https://api.y.uno/v1/sdk/event-log/publish', (req, res, ctx) => {
+    mockInterceptRequest(req.body);
+    return res(ctx.status(200));
+}));
 describe('EventLog', () => {
+    let eventLog;
+    beforeAll(() => {
+        mockInterceptRequest = jest.fn();
+        server.listen();
+    });
+    // Reset any request handlers that we may add during the tests,
+    // so they don't affect other tests.
+    afterEach(() => server.resetHandlers());
+    // Clean up after the tests are finished.
+    afterAll(() => server.close());
     beforeEach(() => {
-        // Reset the database before each test
-        // to ensure a clean slate
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 500,
-            enableEvents: true,
-            enableLogs: true,
+        eventLog = new index_1.EventLog({
+            organizationName: 'testOrg',
+            debug: false,
         });
-        database_1.database.reset();
     });
-    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        yield new Promise((resolve) => setTimeout(resolve, 1000));
-    }));
-    it('should add an event to the database', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.event(eventArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject(eventArgs);
-    }));
-    it('should not add an event to the database if events are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: true,
-        });
-        index_1.eventLog.event(eventArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
-    }));
-    it('should log an error', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.logger.error(logArgs);
-        index_1.eventLog.logger.error(logArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(2);
-        expect(events[0]).toMatchObject(logArgs);
-        expect(events[1]).toMatchObject(logArgs);
-    }));
-    it('should not log an error if logs are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: false,
-        });
-        index_1.eventLog.logger.error(logArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
-    }));
-    it('should log a debug message', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.logger.debug(logArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject(logArgs);
-    }));
-    it('should not log a debug message if logs are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: false,
-        });
-        index_1.eventLog.logger.debug(logArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
-    }));
-    it('should log an info message', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.logger.info(logArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject(logArgs);
-    }));
-    it('should not log an info message if logs are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: false,
-        });
-        index_1.eventLog.logger.info(logArgs);
-        const events = yield database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
-    }));
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('event', () => {
+        it('should add an event to the database if events are enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            eventLog.event(eventArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [Object.assign(Object.assign({}, eventArgs), { type: types_1.EventLogType.EVENT })],
+            });
+        }));
+        it('should not add an event to the database if events are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const publicApiKey = 'testApiKey';
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                enableEvents: false,
+            });
+            eventLog.event(eventArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        }));
+    });
+    describe('logger', () => {
+        it('should add an error log to the database if logs are enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            eventLog.logger.error(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [Object.assign(Object.assign({}, logArgs), { type: types_1.EventLogType.LOG, level: types_1.Level.ERROR })],
+            });
+        }));
+        it('should not add an error log to the database if logs are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const publicApiKey = 'testApiKey';
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                enableEvents: true,
+                enableLogs: false,
+                debug: false,
+            });
+            eventLog.logger.error(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        }));
+        it('should add a debug log to the database if logs are enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            eventLog.logger.debug(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [Object.assign(Object.assign({}, logArgs), { type: types_1.EventLogType.LOG, level: types_1.Level.DEBUG })],
+            });
+        }));
+        it('should not add a debug log to the database if logs are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const publicApiKey = 'testApiKey';
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                platform: 'web',
+                enableEvents: true,
+                enableLogs: false,
+                debug: false,
+            });
+            eventLog.logger.debug(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        }));
+        it('should add an info log to the database if logs are enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            eventLog.logger.info(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [Object.assign(Object.assign({}, logArgs), { type: types_1.EventLogType.LOG, level: types_1.Level.INFO })],
+            });
+        }));
+        it('should not add an info log to the database if logs are disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                platform: 'web',
+                enableEvents: true,
+                enableLogs: false,
+                debug: false,
+            });
+            eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        }));
+    });
+    describe('sendBatch', () => {
+        it('should not send a batch of items to the API if there are no items in the database', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield eventLog.sendBatch();
+            yield new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        }));
+    });
+    describe('Cron', () => {
+        it('should send a batch of items to the API', () => __awaiter(void 0, void 0, void 0, function* () {
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                platform: 'web',
+                batchTime: 1000,
+                enableEvents: true,
+                enableLogs: true,
+                debug: false,
+            });
+            yield eventLog.event(eventArgs, publicApiKey);
+            yield eventLog.logger.error(logArgs, publicApiKey);
+            yield eventLog.logger.debug(logArgs, publicApiKey);
+            yield eventLog.logger.info(logArgs, publicApiKey);
+            yield new Promise((resolve) => setTimeout(resolve, 1200));
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [
+                    Object.assign(Object.assign({}, eventArgs), { type: types_1.EventLogType.EVENT }),
+                    Object.assign(Object.assign({}, logArgs), { type: types_1.EventLogType.LOG, level: types_1.Level.ERROR }),
+                    Object.assign(Object.assign({}, logArgs), { type: types_1.EventLogType.LOG, level: types_1.Level.DEBUG }),
+                    Object.assign(Object.assign({}, logArgs), { type: types_1.EventLogType.LOG, level: types_1.Level.INFO }),
+                ],
+            });
+        }));
+    });
 });

package/dist/cjs/index.types.d.ts

@@ -1,8 +1,8 @@
 export type InitArgs = {
-    publicApiKey: string;
+    organizationName: string;
     batchTime?: number;
-    enableEvents: boolean;
-    enableLogs: boolean;
+    enableEvents?: boolean;
+    enableLogs?: boolean;
     platform?: string;
     debug?: boolean;
 };

package/dist/cjs/index.utils.d.ts

@@ -1,2 +1,3 @@
+import { Database } from './database';
 import { Level, Log } from './types';
-export declare function setLog(logArgs: Omit<Log, 'level' | 'type'>, level: Level, enableLog: boolean): Promise<void> | undefined;
+export declare function setLog(logArgs: Omit<Log, 'level' | 'type'>, level: Level, enableLog: boolean, database: Database, publicApiKey: string): Promise<void> | undefined;

package/dist/cjs/index.utils.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setLog = void 0;
-const database_1 = require("./database");
 const types_1 = require("./types");
-function setLog(logArgs, level, enableLog) {
+function setLog(logArgs, level, enableLog, database, publicApiKey) {
     if (!enableLog) {
         return;
     }
-    return database_1.database.setItem(Object.assign(Object.assign({}, logArgs), { level, type: types_1.EventLogType.LOG }));
+    return database.setItem(Object.assign(Object.assign({}, logArgs), { level, type: types_1.EventLogType.LOG }), publicApiKey);
 }
 exports.setLog = setLog;

package/dist/esm/api/__tests__/api.test.js

@@ -10,15 +10,10 @@ describe('Api', () => {
     let api;
     beforeEach(() => {
         // Reset the instance before each test
-        api = new api_1.Api(publicApiKey, platform);
-    });
-    it('should thorw an error if the instance is not initialized well', () => {
-        expect(() => new api_1.Api('', '')).toThrowError();
+        api = new api_1.Api(platform, true);
     });
     it('should initialize the instance with the correct headers', () => {
         const instance = api.getInstances();
-        expect(instance === null || instance === void 0 ? void 0 : instance.defaults.baseURL).toBe('https://api-staging.y.uno/v1');
-        expect(instance === null || instance === void 0 ? void 0 : instance.defaults.headers['public-api-key']).toBe(publicApiKey);
         expect(instance === null || instance === void 0 ? void 0 : instance.defaults.headers['X-Platform']).toBe(platform);
     });
     it('should send a batch of events to the server', async () => {
@@ -31,7 +26,7 @@ describe('Api', () => {
                 type: types_1.EventLogType.EVENT,
             },
         ];
-        const response = await api.sendBatch(batches);
+        const response = await api.sendBatch(batches, publicApiKey);
         expect(response === null || response === void 0 ? void 0 : response.status).toBe(STATUS_CREATED);
     });
     it('should return the instance', () => {

package/dist/esm/api/api.d.ts

@@ -2,7 +2,7 @@ import { AxiosInstance } from 'axios';
 import { Batch } from '../types';
 export declare class Api {
     #private;
-    constructor(publicApiKey: string, platform: string, debug?: boolean);
-    sendBatch(batches: Batch[]): Promise<import("axios").AxiosResponse<any, any>> | undefined;
+    constructor(platform: string, debug?: boolean);
+    sendBatch(batches: Batch[], publicApiKey: string): Promise<import("axios").AxiosResponse<any, any>> | undefined;
     getInstances(): AxiosInstance | null;
 }

package/dist/esm/api/api.js

@@ -19,22 +19,26 @@ exports.Api = void 0;
 const axios_1 = __importDefault(require("axios"));
 const api_utils_1 = require("./api.utils");
 class Api {
-    constructor(publicApiKey, platform, debug = false) {
+    constructor(platform, debug = false) {
         _Api_instance.set(this, null);
         _Api_debug.set(this, false);
         __classPrivateFieldSet(this, _Api_debug, debug, "f");
         __classPrivateFieldSet(this, _Api_instance, axios_1.default.create({
-            baseURL: (0, api_utils_1.getBaseUrl)(publicApiKey),
             // eslint-disable-next-line @typescript-eslint/naming-convention
-            headers: { 'public-api-key': publicApiKey, 'X-Platform': platform },
+            headers: { 'X-Platform': platform },
         }), "f");
     }
-    sendBatch(batches) {
+    sendBatch(batches, publicApiKey) {
         var _a;
         if (__classPrivateFieldGet(this, _Api_debug, "f")) {
             console.dir(batches, { depth: null });
+            console.log(publicApiKey);
         }
-        return (_a = __classPrivateFieldGet(this, _Api_instance, "f")) === null || _a === void 0 ? void 0 : _a.post('/sdk/event-log/publish', { batch: batches });
+        return (_a = __classPrivateFieldGet(this, _Api_instance, "f")) === null || _a === void 0 ? void 0 : _a.post('/sdk/event-log/publish', { batch: batches }, {
+            baseURL: (0, api_utils_1.getBaseUrl)(publicApiKey),
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            headers: { 'public-api-key': publicApiKey }
+        });
     }
     getInstances() {
         return __classPrivateFieldGet(this, _Api_instance, "f");

package/dist/esm/cron/cron.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import { Api } from '../api';
+import { Database } from '../database';
 export declare class Cron {
     #private;
-    constructor(batchTime: number, api: Api);
-    sendBatch(): void;
+    constructor(batchTime: number, api: Api, database: Database);
+    sendBatch(): Promise<void>;
     stop(): void;
     getInterval(): NodeJS.Timeout | undefined;
 }

package/dist/esm/cron/cron.js

@@ -10,26 +10,28 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Cron_interval, _Cron_api;
+var _Cron_interval, _Cron_api, _Cron_database;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cron = void 0;
-const database_1 = require("../database");
 const NONE_ITEMS = 0;
 class Cron {
-    constructor(batchTime, api) {
+    constructor(batchTime, api, database) {
         _Cron_interval.set(this, void 0);
         _Cron_api.set(this, void 0);
+        _Cron_database.set(this, void 0);
         this.stop();
         __classPrivateFieldSet(this, _Cron_api, api, "f");
+        __classPrivateFieldSet(this, _Cron_database, database, "f");
         __classPrivateFieldSet(this, _Cron_interval, setInterval(this.sendBatch.bind(this), batchTime), "f");
     }
-    sendBatch() {
-        database_1.database.getAllItems().then((items) => {
-            var _a;
-            if (items.length > NONE_ITEMS) {
-                (_a = __classPrivateFieldGet(this, _Cron_api, "f").sendBatch(items)) === null || _a === void 0 ? void 0 : _a.then(() => database_1.database.reset());
+    async sendBatch() {
+        const items = await __classPrivateFieldGet(this, _Cron_database, "f").getAllItems();
+        const keys = Object.keys(items);
+        if (keys.length > NONE_ITEMS) {
+            for (const key of keys) {
+                __classPrivateFieldGet(this, _Cron_api, "f").sendBatch(items[key], key);
             }
-        });
+        }
     }
     stop() {
         if (__classPrivateFieldGet(this, _Cron_interval, "f")) {
@@ -42,4 +44,4 @@ class Cron {
     }
 }
 exports.Cron = Cron;
-_Cron_interval = new WeakMap(), _Cron_api = new WeakMap();
+_Cron_interval = new WeakMap(), _Cron_api = new WeakMap(), _Cron_database = new WeakMap();

package/dist/esm/cron/cron.test.js

@@ -4,19 +4,20 @@ const cron_1 = require("./cron");
 const api_1 = require("../api");
 const database_1 = require("../database");
 const types_1 = require("../types");
-const PUBLIC_API_KEY = 'staging_gAAAAABj-NC2WEf3XA4lHnN6RfGbjETf6qL27jlU7c1tm01ERV-Y-E6ddee1QPyV_CA8cxjVlGy-qDNA2-mqa9msQlTJit-Fmbvv6f2AZdfbFd_CUo1stvixnF4_8MzM_IYVWYz7KK86VfEBvxNpjRCyp7BDef-QzrT1-yqa8HAYTuA1GU3Hjjo=';
 const TIME_INTERVAL = 1000;
 describe('Cron', () => {
     let spy;
     let cron;
     let api;
+    let database;
     beforeEach(async () => {
         // restore the spy created with spyOn
         jest.restoreAllMocks();
-        api = new api_1.Api(PUBLIC_API_KEY, 'test');
-        cron = new cron_1.Cron(TIME_INTERVAL, api);
+        api = new api_1.Api('web', true);
+        database = (0, database_1.databaseFactory)('testOrganization');
+        cron = new cron_1.Cron(TIME_INTERVAL, api, database);
         spy = jest.spyOn(api, 'sendBatch');
-        await database_1.database.reset();
+        await database.reset();
     });
     it('should send a batch of items to the API if there are items in the database', async () => {
         const batch = {
@@ -26,9 +27,9 @@ describe('Cron', () => {
             original_created_at: new Date().toISOString(),
             type: types_1.EventLogType.EVENT,
         };
-        database_1.database.setItem(batch);
+        database.setItem(batch, 'sandbox_1');
         await cron.sendBatch();
-        expect(spy).toHaveBeenCalledWith([batch]);
+        expect(spy).toHaveBeenCalledWith([batch], 'sandbox_1');
     });
     it('should not send a batch of items to the API if there are no items in the database', async () => {
         await cron.sendBatch();

package/dist/esm/database/database.d.ts

@@ -1,3 +1,2 @@
 import { Database } from './database.types';
-export declare function databaseFactory(): Database;
-export declare const database: Database;
+export declare function databaseFactory(organizationName: string): Database;

package/dist/esm/database/database.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.database = exports.databaseFactory = void 0;
+exports.databaseFactory = void 0;
 const local_storage_1 = require("./local-storage");
 const memory_storage_1 = require("./memory-storage");
-function databaseFactory() {
+function databaseFactory(organizationName) {
     const databaseType = isLocalStorageEnabled()
         ? 'local-storage'
         : 'memory-storage';
     switch (databaseType) {
         case 'local-storage':
-            return new local_storage_1.LocalStorage();
+            return new local_storage_1.LocalStorage(organizationName);
         case 'memory-storage':
             return new memory_storage_1.MemoryStorage();
         default:
@@ -28,4 +28,3 @@ function isLocalStorageEnabled() {
         return false;
     }
 }
-exports.database = databaseFactory();

package/dist/esm/database/database.test.js

@@ -11,7 +11,7 @@ describe('databaseFactory', () => {
     it('should return a LocalStorage instance if local storage is enabled', () => {
         jest.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { });
         jest.spyOn(Storage.prototype, 'removeItem').mockImplementation(() => { });
-        const result = (0, database_1.databaseFactory)();
+        const result = (0, database_1.databaseFactory)('testOrganization');
         expect(result).toBeInstanceOf(local_storage_1.LocalStorage);
     });
     it('should return a MemoryStorage instance if local storage is not enabled', () => {
@@ -19,7 +19,7 @@ describe('databaseFactory', () => {
             throw new Error('Local storage not available');
         });
         jest.spyOn(Storage.prototype, 'removeItem').mockImplementation(() => { });
-        const result = (0, database_1.databaseFactory)();
+        const result = (0, database_1.databaseFactory)('testOrganization');
         expect(result).toBeInstanceOf(memory_storage_1.MemoryStorage);
     });
 });

package/dist/esm/database/database.types.d.ts

@@ -1,8 +1,8 @@
 import { Batch } from '../types';
 export interface Database {
-    setItem(item: Batch): Promise<void>;
+    setItem(item: Batch, publicApiKey: string): Promise<void>;
     getItem(id: string): Promise<Batch>;
     removeItem(id: string): Promise<void>;
-    getAllItems(): Promise<Batch[]>;
+    getAllItems(): Promise<Record<string, Batch[]>>;
     reset(): Promise<void>;
 }

package/dist/esm/database/index.d.ts

@@ -1 +1,2 @@
 export * from './database';
+export * from './database.types';

package/dist/esm/database/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./database"), exports);
+__exportStar(require("./database.types"), exports);

package/dist/esm/database/local-storage/local-storage.d.ts

@@ -2,10 +2,10 @@ import { Batch } from '../../types';
 import { Database } from '../database.types';
 export declare class LocalStorage implements Database {
     #private;
-    constructor();
+    constructor(organizationName: string);
     reset(): Promise<void>;
-    setItem(item: Batch): Promise<void>;
+    setItem(item: Batch, publicApiKey: string): Promise<void>;
     getItem(id: string): Promise<Batch>;
     removeItem(id: string): Promise<void>;
-    getAllItems(): Promise<Batch[]>;
+    getAllItems(): Promise<Record<string, Batch[]>>;
 }

package/dist/esm/database/local-storage/local-storage.js

@@ -13,23 +13,29 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LocalStorage_instances, _LocalStorage_localStorage, _LocalStorage_databaseName, _LocalStorage_getDatabase;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorage = void 0;
+const DATABASE_NAME_SPACE = 'YUNO_EVENT_LOGS';
 class LocalStorage {
-    constructor() {
+    constructor(organizationName) {
         _LocalStorage_instances.add(this);
         _LocalStorage_localStorage.set(this, void 0);
-        _LocalStorage_databaseName.set(this, 'YUNO_EVENT_LOGS');
+        _LocalStorage_databaseName.set(this, void 0);
         __classPrivateFieldSet(this, _LocalStorage_localStorage, window.localStorage, "f");
+        __classPrivateFieldSet(this, _LocalStorage_databaseName, `${DATABASE_NAME_SPACE}_${organizationName}`, "f");
         const database = __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").getItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"));
         if (database === null || database === undefined) {
-            __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify([]));
+            this.reset();
         }
     }
     async reset() {
-        __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify([]));
+        __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify({}));
     }
-    async setItem(item) {
+    async setItem(item, publicApiKey) {
         const database = __classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_getDatabase).call(this);
-        __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify([...database, item]));
+        if (database[publicApiKey] === undefined) {
+            database[publicApiKey] = [];
+        }
+        database[publicApiKey].push(item);
+        __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify(database));
     }
     getItem(id) {
         throw new Error('Method not implemented.' + id);
@@ -38,14 +44,16 @@ class LocalStorage {
         throw new Error('Method not implemented.' + id);
     }
     getAllItems() {
-        return Promise.resolve(__classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_getDatabase).call(this));
+        const database = __classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_getDatabase).call(this);
+        this.reset();
+        return Promise.resolve(database);
     }
 }
 exports.LocalStorage = LocalStorage;
 _LocalStorage_localStorage = new WeakMap(), _LocalStorage_databaseName = new WeakMap(), _LocalStorage_instances = new WeakSet(), _LocalStorage_getDatabase = function _LocalStorage_getDatabase() {
     let database = __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").getItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"));
     if (database === null || database === undefined) {
-        database = JSON.stringify([]);
+        database = JSON.stringify({});
         __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), database);
     }
     return JSON.parse(database);

package/dist/esm/database/local-storage/local-storage.test.js

@@ -12,19 +12,20 @@ const batch = {
 describe('LocalStorageDatabase', () => {
     let localStorageDatabase;
     beforeEach(() => {
-        localStorageDatabase = new local_storage_1.LocalStorage();
+        localStorageDatabase = new local_storage_1.LocalStorage('test');
     });
     afterEach(() => {
         localStorage.clear();
     });
     it('should set an item in the database', async () => {
-        await localStorageDatabase.setItem(batch);
-        const database = JSON.parse(localStorage.getItem('YUNO_EVENT_LOGS') || '[]');
-        expect(database).toContainEqual(batch);
+        const testKey = 'testKey';
+        await localStorageDatabase.setItem(batch, testKey);
+        const database = JSON.parse(localStorage.getItem('YUNO_EVENT_LOGS_test') || '[]');
+        expect(database).toEqual({ [testKey]: [batch] });
     });
     it('should get an item from the database', async () => {
-        localStorage.setItem('YUNO_EVENT_LOGS', JSON.stringify([batch]));
+        localStorage.setItem('YUNO_EVENT_LOGS_test', JSON.stringify({ testKey: [batch] }));
         const result = await localStorageDatabase.getAllItems();
-        expect(result).toEqual([batch]);
+        expect(result).toEqual({ testKey: [batch] });
     });
 });

package/dist/esm/database/memory-storage/memory-storage.d.ts

@@ -4,8 +4,10 @@ export declare class MemoryStorage implements Database {
     #private;
     constructor();
     reset(): Promise<void>;
-    setItem(item: Batch): Promise<void>;
+    setItem(item: Batch, publicApiKey: string): Promise<void>;
     getItem(id: string): Promise<Batch>;
     removeItem(id: string): Promise<void>;
-    getAllItems(): Promise<Batch[]>;
+    getAllItems(): Promise<{
+        [x: string]: Batch[];
+    }>;
 }