@yuno-payments/sdk-event-log 0.3.0-beta.12 → 0.3.0-beta.8

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

@@ -16,13 +16,17 @@ const publicApiKey = PUBLIC_API_KEY;
 const platform = 'web';
 const STATUS_CREATED = 201;
 describe('Api', () => {
-    let api;
     beforeEach(() => {
         // Reset the instance before each test
-        api = new api_1.Api(platform, true);
+        api_1.api.init(publicApiKey, platform);
+    });
+    it('should thorw an error if the instance is not initialized well', () => {
+        expect(() => api_1.api.init('', '')).toThrowError();
     });
     it('should initialize the instance with the correct headers', () => {
-        const instance = api.getInstances();
+        const instance = api_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -35,11 +39,11 @@ describe('Api', () => {
                 type: types_1.EventLogType.EVENT,
             },
         ];
-        const response = yield api.sendBatch(batches, publicApiKey);
+        const response = yield api_1.api.sendBatch(batches);
         expect(response === null || response === void 0 ? void 0 : response.status).toBe(STATUS_CREATED);
     }));
     it('should return the instance', () => {
-        const instance = api.getInstances();
+        const instance = api_1.api.getInstances();
         expect(instance).not.toBeNull();
     });
 });

package/dist/cjs/api/api.d.ts

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

package/dist/cjs/api/api.js

@@ -15,34 +15,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var _Api_instance, _Api_debug;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = void 0;
+exports.api = void 0;
 const axios_1 = __importDefault(require("axios"));
 const api_utils_1 = require("./api.utils");
 class Api {
-    constructor(platform, debug = false) {
+    constructor() {
         _Api_instance.set(this, null);
         _Api_debug.set(this, false);
+    }
+    init(publicApiKey, platform, debug = 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: { 'X-Platform': platform },
+            headers: { 'public-api-key': publicApiKey, 'X-Platform': platform },
         }), "f");
     }
-    sendBatch(batches, publicApiKey) {
+    sendBatch(batches) {
         var _a;
-        if (__classPrivateFieldGet(this, _Api_debug, "f")) {
+        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 }, {
-            baseURL: (0, api_utils_1.getBaseUrl)(publicApiKey),
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            headers: { 'public-api-key': publicApiKey }
-        });
+        return (_a = __classPrivateFieldGet(this, _Api_instance, "f")) === null || _a === void 0 ? void 0 : _a.post('/sdk/event-log/publish', { batch: batches });
     }
     getInstances() {
         return __classPrivateFieldGet(this, _Api_instance, "f");
     }
 }
-exports.Api = Api;
 _Api_instance = new WeakMap(), _Api_debug = new WeakMap();
+exports.api = new Api();

package/dist/cjs/cron/cron.d.ts

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

package/dist/cjs/cron/cron.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -19,28 +10,27 @@ 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, _Cron_database;
+var _Cron_interval;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cron = void 0;
+exports.cron = void 0;
+const api_1 = require("../api");
+const database_1 = require("../database");
 const NONE_ITEMS = 0;
 class Cron {
-    constructor(batchTime, api, database) {
+    constructor() {
         _Cron_interval.set(this, void 0);
-        _Cron_api.set(this, void 0);
-        _Cron_database.set(this, void 0);
+    }
+    init(batchTime) {
         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");
+        __classPrivateFieldSet(this, _Cron_interval, setInterval(this.sendBatch, batchTime), "f");
+        console.log('cron started');
     }
     sendBatch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const items = yield __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);
-                }
+        database_1.database.getAllItems().then((items) => {
+            var _a;
+            console.log('items', items);
+            if (items.length > NONE_ITEMS) {
+                (_a = api_1.api.sendBatch(items)) === null || _a === void 0 ? void 0 : _a.then(() => database_1.database.reset());
             }
         });
     }
@@ -54,5 +44,5 @@ class Cron {
         return __classPrivateFieldGet(this, _Cron_interval, "f");
     }
 }
-exports.Cron = Cron;
-_Cron_interval = new WeakMap(), _Cron_api = new WeakMap(), _Cron_database = new WeakMap();
+_Cron_interval = new WeakMap();
+exports.cron = new Cron();

package/dist/cjs/cron/cron.test.js

@@ -16,17 +16,11 @@ const types_1 = require("../types");
 const TIME_INTERVAL = 1000;
 describe('Cron', () => {
     let spy;
-    let cron;
-    let api;
-    let database;
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         // restore the spy created with spyOn
         jest.restoreAllMocks();
-        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');
-        yield database.reset();
+        spy = jest.spyOn(api_1.api, 'sendBatch');
+        yield database_1.database.reset();
     }));
     it('should send a batch of items to the API if there are items in the database', () => __awaiter(void 0, void 0, void 0, function* () {
         const batch = {
@@ -36,21 +30,23 @@ describe('Cron', () => {
             original_created_at: new Date().toISOString(),
             type: types_1.EventLogType.EVENT,
         };
-        database.setItem(batch, 'sandbox_1');
-        yield cron.sendBatch();
-        expect(spy).toHaveBeenCalledWith([batch], 'sandbox_1');
+        database_1.database.setItem(batch);
+        yield cron_1.cron.sendBatch();
+        expect(spy).toHaveBeenCalledWith([batch]);
     }));
     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 cron.sendBatch();
+        yield cron_1.cron.sendBatch();
         expect(spy).not.toHaveBeenCalled();
     }));
     it('should stop the interval when stop is called', () => {
         jest.useFakeTimers();
-        cron.stop();
-        expect(cron.getInterval()).toBeUndefined();
+        cron_1.cron.init(TIME_INTERVAL);
+        cron_1.cron.stop();
+        expect(cron_1.cron.getInterval()).toBeUndefined();
     });
     it('should start the interval when init is called', () => {
         jest.useFakeTimers();
-        expect(cron.getInterval()).toBeDefined();
+        cron_1.cron.init(TIME_INTERVAL);
+        expect(cron_1.cron.getInterval()).toBeDefined();
     });
 });

package/dist/cjs/database/database.d.ts

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

package/dist/cjs/database/database.js

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

package/dist/cjs/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)('testOrganization');
+        const result = (0, database_1.databaseFactory)();
         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)('testOrganization');
+        const result = (0, database_1.databaseFactory)();
         expect(result).toBeInstanceOf(memory_storage_1.MemoryStorage);
     });
 });

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

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

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

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

package/dist/cjs/database/index.js

@@ -15,4 +15,3 @@ 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/cjs/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(organizationName: string);
+    constructor();
     reset(): Promise<void>;
-    setItem(item: Batch, publicApiKey: string): Promise<void>;
+    setItem(item: Batch): Promise<void>;
     getItem(id: string): Promise<Batch>;
     removeItem(id: string): Promise<void>;
-    getAllItems(): Promise<Record<string, Batch[]>>;
+    getAllItems(): Promise<Batch[]>;
 }

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

@@ -19,36 +19,29 @@ 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 _LocalStorage_instances, _LocalStorage_localStorage, _LocalStorage_databaseName, _LocalStorage_getDatabase, _LocalStorage_stringify;
+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';
-const DO_NOT_EXIST = -1;
 class LocalStorage {
-    constructor(organizationName) {
+    constructor() {
         _LocalStorage_instances.add(this);
         _LocalStorage_localStorage.set(this, void 0);
-        _LocalStorage_databaseName.set(this, void 0);
+        _LocalStorage_databaseName.set(this, 'YUNO_EVENT_LOGS');
         __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) {
-            this.reset();
+            __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify([]));
         }
     }
     reset() {
         return __awaiter(this, void 0, void 0, function* () {
-            __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([]));
         });
     }
-    setItem(item, publicApiKey) {
+    setItem(item) {
         return __awaiter(this, void 0, void 0, function* () {
             const database = __classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_getDatabase).call(this);
-            if (database[publicApiKey] === undefined) {
-                database[publicApiKey] = [];
-            }
-            database[publicApiKey].push(item);
-            __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), __classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_stringify).call(this, database));
+            __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify([...database, item]));
         });
     }
     getItem(id) {
@@ -58,31 +51,15 @@ class LocalStorage {
         throw new Error('Method not implemented.' + id);
     }
     getAllItems() {
-        const database = __classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_getDatabase).call(this);
-        this.reset();
-        return Promise.resolve(database);
+        return Promise.resolve(__classPrivateFieldGet(this, _LocalStorage_instances, "m", _LocalStorage_getDatabase).call(this));
     }
 }
 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);
-}, _LocalStorage_stringify = function _LocalStorage_stringify(obj) {
-    const cache = [];
-    const str = JSON.stringify(obj, function (key, value) {
-        if (typeof value === 'object' && value !== null) {
-            if (cache.indexOf(value) !== DO_NOT_EXIST) {
-                // Circular reference found, discard key
-                return;
-            }
-            // Store value in our collection
-            cache.push(value);
-        }
-        return value;
-    });
-    return str;
 };

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

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

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

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

package/dist/cjs/database/memory-storage/memory-storage.js

@@ -25,19 +25,16 @@ exports.MemoryStorage = void 0;
 class MemoryStorage {
     constructor() {
         _MemoryStorage_items.set(this, void 0);
-        __classPrivateFieldSet(this, _MemoryStorage_items, {}, "f");
+        __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
     }
     reset() {
         return __awaiter(this, void 0, void 0, function* () {
-            __classPrivateFieldSet(this, _MemoryStorage_items, {}, "f");
+            __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
         });
     }
-    setItem(item, publicApiKey) {
+    setItem(item) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (__classPrivateFieldGet(this, _MemoryStorage_items, "f")[publicApiKey] === undefined) {
-                __classPrivateFieldGet(this, _MemoryStorage_items, "f")[publicApiKey] = [];
-            }
-            __classPrivateFieldGet(this, _MemoryStorage_items, "f")[publicApiKey].push(item);
+            __classPrivateFieldGet(this, _MemoryStorage_items, "f").push(item);
         });
     }
     getItem(id) {
@@ -47,9 +44,7 @@ class MemoryStorage {
         throw new Error('Method not implemented.' + id);
     }
     getAllItems() {
-        const items = Object.assign({}, __classPrivateFieldGet(this, _MemoryStorage_items, "f"));
-        this.reset();
-        return Promise.resolve(items);
+        return Promise.resolve(__classPrivateFieldGet(this, _MemoryStorage_items, "f"));
     }
 }
 exports.MemoryStorage = MemoryStorage;

package/dist/cjs/database/memory-storage/memory-storage.test.js

@@ -27,8 +27,8 @@ describe('MemoryStorage', () => {
         memoryStorage.reset();
     });
     it('should set an item in the database', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield memoryStorage.setItem(batch, 'testKey');
+        yield memoryStorage.setItem(batch);
         const database = yield memoryStorage.getAllItems();
-        expect(database).toEqual({ testKey: [batch] });
+        expect(database).toEqual([batch]);
     }));
 });

package/dist/cjs/index.d.ts

@@ -1,13 +1,15 @@
 import { InitArgs } from './index.types';
+import './database';
 import { Event, Log } from './types';
-export declare class EventLog {
+declare class EventLog {
     #private;
-    constructor({ organizationName, platform, batchTime, enableEvents, enableLogs, debug, }: InitArgs);
-    event(eventArgs: Omit<Event, 'type'>, publicApiKey: string): Promise<void> | undefined;
+    init({ publicApiKey, platform, batchTime, enableEvents, enableLogs, debug }: InitArgs): void;
+    event(eventArgs: Omit<Event, 'type'>): Promise<void> | undefined;
     logger: {
-        error: (errorArgs: Omit<Log, 'level' | 'type'>, publicApiKey: string) => Promise<void> | undefined;
-        debug: (debugArgs: Omit<Log, 'level' | 'type'>, publicApiKey: string) => Promise<void> | undefined;
-        info: (infoArgs: Omit<Log, 'level' | 'type'>, publicApiKey: string) => Promise<void> | undefined;
+        error: (errorArgs: Omit<Log, 'level' | 'type'>) => Promise<void> | undefined;
+        debug: (debugArgs: Omit<Log, 'level' | 'type'>) => Promise<void> | undefined;
+        info: (infoArgs: Omit<Log, 'level' | 'type'>) => Promise<void> | undefined;
     };
-    sendBatch(): Promise<void>;
 }
+export declare const eventLog: EventLog;
+export {};

package/dist/cjs/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -19,56 +10,43 @@ 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 _EventLog_enableEvents, _EventLog_enableLogs, _EventLog_api, _EventLog_database;
+var _EventLog_enableEvents, _EventLog_enableLogs;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventLog = void 0;
+exports.eventLog = void 0;
 const api_1 = require("./api");
+require("./database");
 const cron_1 = require("./cron");
 const types_1 = require("./types");
 const database_1 = require("./database");
 const index_utils_1 = require("./index.utils");
 class EventLog {
-    constructor({ organizationName, platform = 'web', batchTime, enableEvents = true, enableLogs = true, debug = false, }) {
-        _EventLog_enableEvents.set(this, void 0);
-        _EventLog_enableLogs.set(this, void 0);
-        _EventLog_api.set(this, void 0);
-        _EventLog_database.set(this, void 0);
+    constructor() {
+        _EventLog_enableEvents.set(this, false);
+        _EventLog_enableLogs.set(this, false);
         this.logger = {
-            error: (errorArgs, publicApiKey) => {
-                return (0, index_utils_1.setLog)(errorArgs, types_1.Level.ERROR, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"), publicApiKey);
-            },
-            debug: (debugArgs, publicApiKey) => {
-                return (0, index_utils_1.setLog)(debugArgs, types_1.Level.DEBUG, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"), publicApiKey);
+            error: (errorArgs) => {
+                return (0, index_utils_1.setLog)(errorArgs, types_1.Level.ERROR, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
             },
-            info: (infoArgs, publicApiKey) => {
-                return (0, index_utils_1.setLog)(infoArgs, types_1.Level.INFO, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"), publicApiKey);
+            debug: (debugArgs) => {
+                return (0, index_utils_1.setLog)(debugArgs, types_1.Level.DEBUG, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
             },
+            info: (infoArgs) => {
+                return (0, index_utils_1.setLog)(infoArgs, types_1.Level.INFO, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
+            }
         };
+    }
+    init({ publicApiKey, platform = 'web', batchTime, enableEvents, enableLogs, debug = false }) {
         __classPrivateFieldSet(this, _EventLog_enableEvents, enableEvents, "f");
         __classPrivateFieldSet(this, _EventLog_enableLogs, enableLogs, "f");
-        __classPrivateFieldSet(this, _EventLog_api, new api_1.Api(platform, debug), "f");
-        __classPrivateFieldSet(this, _EventLog_database, (0, database_1.databaseFactory)(organizationName), "f");
-        if (batchTime) {
-            new cron_1.Cron(batchTime, __classPrivateFieldGet(this, _EventLog_api, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"));
-        }
+        api_1.api.init(publicApiKey, platform, debug);
+        cron_1.cron.init(batchTime);
     }
-    event(eventArgs, publicApiKey) {
+    event(eventArgs) {
         if (!__classPrivateFieldGet(this, _EventLog_enableEvents, "f")) {
             return;
         }
-        return __classPrivateFieldGet(this, _EventLog_database, "f").setItem(Object.assign(Object.assign({}, eventArgs), { type: types_1.EventLogType.EVENT }), publicApiKey);
-    }
-    sendBatch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const items = yield __classPrivateFieldGet(this, _EventLog_database, "f").getAllItems();
-            const keys = Object.keys(items);
-            if (keys.length) {
-                for (const key of keys) {
-                    __classPrivateFieldGet(this, _EventLog_api, "f").sendBatch(items[key], key);
-                }
-            }
-        });
+        return database_1.database.setItem(Object.assign(Object.assign({}, eventArgs), { type: types_1.EventLogType.EVENT }));
     }
 }
-exports.EventLog = EventLog;
-_EventLog_enableEvents = new WeakMap(), _EventLog_enableLogs = new WeakMap(), _EventLog_api = new WeakMap(), _EventLog_database = new WeakMap();
+_EventLog_enableEvents = new WeakMap(), _EventLog_enableLogs = new WeakMap();
+exports.eventLog = new EventLog();