@yuno-payments/sdk-event-log 0.2.0

package/dist/esm/cron/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cron"), exports);

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

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

package/dist/esm/database/database.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.database = exports.databaseFactory = void 0;
+const local_storage_1 = require("./local-storage");
+const memory_storage_1 = require("./memory-storage");
+function databaseFactory() {
+    const databaseType = isLocalStorageEnabled()
+        ? 'local-storage'
+        : 'memory-storage';
+    switch (databaseType) {
+        case 'local-storage':
+            return new local_storage_1.LocalStorage();
+        case 'memory-storage':
+            return new memory_storage_1.MemoryStorage();
+        default:
+            throw new Error(`Database type ${databaseType} not supported`);
+    }
+}
+exports.databaseFactory = databaseFactory;
+function isLocalStorageEnabled() {
+    try {
+        const key = '__yuno_storage__test';
+        window.localStorage.setItem(key, 'test_value');
+        window.localStorage.removeItem(key);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.database = databaseFactory();

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_1 = require("./database");
+const local_storage_1 = require("./local-storage");
+const memory_storage_1 = require("./memory-storage");
+describe('databaseFactory', () => {
+    beforeEach(() => {
+        // restore the spy created with spyOn
+        jest.restoreAllMocks();
+    });
+    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)();
+        expect(result).toBeInstanceOf(local_storage_1.LocalStorage);
+    });
+    it('should return a MemoryStorage instance if local storage is not enabled', () => {
+        jest.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+            throw new Error('Local storage not available');
+        });
+        jest.spyOn(Storage.prototype, 'removeItem').mockImplementation(() => { });
+        const result = (0, database_1.databaseFactory)();
+        expect(result).toBeInstanceOf(memory_storage_1.MemoryStorage);
+    });
+});

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

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

package/dist/esm/database/database.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/esm/database/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./database"), exports);

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

@@ -0,0 +1 @@
+export * from './local-storage';

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./local-storage"), exports);

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

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

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

@@ -0,0 +1,52 @@
+"use strict";
+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");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorage = void 0;
+class LocalStorage {
+    constructor() {
+        _LocalStorage_instances.add(this);
+        _LocalStorage_localStorage.set(this, void 0);
+        _LocalStorage_databaseName.set(this, 'YUNO_EVENT_LOGS');
+        __classPrivateFieldSet(this, _LocalStorage_localStorage, window.localStorage, "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([]));
+        }
+    }
+    async reset() {
+        __classPrivateFieldGet(this, _LocalStorage_localStorage, "f").setItem(__classPrivateFieldGet(this, _LocalStorage_databaseName, "f"), JSON.stringify([]));
+    }
+    async setItem(item) {
+        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]));
+    }
+    getItem(id) {
+        throw new Error('Method not implemented.' + id);
+    }
+    removeItem(id) {
+        throw new Error('Method not implemented.' + id);
+    }
+    getAllItems() {
+        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([]);
+        __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.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const local_storage_1 = require("./local-storage");
+const batch = {
+    source: 'test',
+    event: 'testEvent',
+    description: 'Test event',
+    original_created_at: new Date().toISOString(),
+    type: types_1.EventLogType.EVENT,
+};
+describe('LocalStorageDatabase', () => {
+    let localStorageDatabase;
+    beforeEach(() => {
+        localStorageDatabase = new local_storage_1.LocalStorage();
+    });
+    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);
+    });
+    it('should get an item from the database', async () => {
+        localStorage.setItem('YUNO_EVENT_LOGS', JSON.stringify([batch]));
+        const result = await localStorageDatabase.getAllItems();
+        expect(result).toEqual([batch]);
+    });
+});

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

@@ -0,0 +1 @@
+export * from './memory-storage';

package/dist/esm/database/memory-storage/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./memory-storage"), exports);

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+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");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _MemoryStorage_items;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+class MemoryStorage {
+    constructor() {
+        _MemoryStorage_items.set(this, void 0);
+        __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
+    }
+    async reset() {
+        __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
+    }
+    async setItem(item) {
+        __classPrivateFieldGet(this, _MemoryStorage_items, "f").push(item);
+    }
+    getItem(id) {
+        throw new Error('Method not implemented.' + id);
+    }
+    removeItem(id) {
+        throw new Error('Method not implemented.' + id);
+    }
+    getAllItems() {
+        return Promise.resolve(__classPrivateFieldGet(this, _MemoryStorage_items, "f"));
+    }
+}
+exports.MemoryStorage = MemoryStorage;
+_MemoryStorage_items = new WeakMap();

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const memory_storage_1 = require("./memory-storage");
+const batch = {
+    source: 'test',
+    event: 'testEvent',
+    description: 'Test event',
+    original_created_at: new Date().toISOString(),
+    type: types_1.EventLogType.EVENT,
+};
+describe('MemoryStorage', () => {
+    let memoryStorage;
+    beforeEach(() => {
+        memoryStorage = new memory_storage_1.MemoryStorage();
+    });
+    afterEach(() => {
+        memoryStorage.reset();
+    });
+    it('should set an item in the database', async () => {
+        await memoryStorage.setItem(batch);
+        const database = await memoryStorage.getAllItems();
+        expect(database).toEqual([batch]);
+    });
+});

package/dist/esm/index.d.ts

@@ -0,0 +1,15 @@
+import { InitArgs } from './index.types';
+import './database';
+import { Event, Log } from './types';
+declare class EventLog {
+    #private;
+    init({ publicApiKey, platform, batchTime, enableEvents, enableLogs }: InitArgs): void;
+    event(eventArgs: Omit<Event, 'type'>): Promise<void> | undefined;
+    logger: {
+        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;
+    };
+}
+export declare const eventLog: EventLog;
+export {};

package/dist/esm/index.js

@@ -0,0 +1,52 @@
+"use strict";
+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");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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;
+Object.defineProperty(exports, "__esModule", { value: true });
+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() {
+        _EventLog_enableEvents.set(this, false);
+        _EventLog_enableLogs.set(this, false);
+        this.logger = {
+            error: (errorArgs) => {
+                return (0, index_utils_1.setLog)(errorArgs, types_1.Level.ERROR, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
+            },
+            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 }) {
+        __classPrivateFieldSet(this, _EventLog_enableEvents, enableEvents, "f");
+        __classPrivateFieldSet(this, _EventLog_enableLogs, enableLogs, "f");
+        api_1.api.init(publicApiKey, platform);
+        cron_1.cron.init(batchTime);
+    }
+    event(eventArgs) {
+        if (!__classPrivateFieldGet(this, _EventLog_enableEvents, "f")) {
+            return;
+        }
+        return database_1.database.setItem({ ...eventArgs, type: types_1.EventLogType.EVENT });
+    }
+}
+_EventLog_enableEvents = new WeakMap(), _EventLog_enableLogs = new WeakMap();
+exports.eventLog = new EventLog();

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.test.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const database_1 = require("./database");
+const cron_1 = require("./cron");
+const PUBLIC_API_KEY = 'staging_gAAAAABj-NC2WEf3XA4lHnN6RfGbjETf6qL27jlU7c1tm01ERV-Y-E6ddee1QPyV_CA8cxjVlGy-qDNA2-mqa9msQlTJit-Fmbvv6f2AZdfbFd_CUo1stvixnF4_8MzM_IYVWYz7KK86VfEBvxNpjRCyp7BDef-QzrT1-yqa8HAYTuA1GU3Hjjo=';
+const eventArgs = {
+    source: 'test',
+    event: 'testEvent',
+    description: 'Test event',
+    original_created_at: new Date().toISOString(),
+};
+const logArgs = {
+    sdk_version: '',
+    url: '',
+    method: '',
+    country: '',
+    original_created_at: new Date().toISOString()
+};
+describe('EventLog', () => {
+    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,
+        });
+        database_1.database.reset();
+    });
+    afterEach(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        cron_1.cron.stop();
+    });
+    it('should add an event to the database', async () => {
+        index_1.eventLog.event(eventArgs);
+        const events = await 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', async () => {
+        index_1.eventLog.init({
+            publicApiKey: PUBLIC_API_KEY,
+            batchTime: 1000,
+            enableEvents: false,
+            enableLogs: true,
+        });
+        index_1.eventLog.event(eventArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(0);
+    });
+    it('should log an error', async () => {
+        index_1.eventLog.logger.error(logArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(1);
+        expect(events[0]).toMatchObject(logArgs);
+    });
+    it('should not log an error if logs are disabled', async () => {
+        index_1.eventLog.init({
+            publicApiKey: PUBLIC_API_KEY,
+            batchTime: 1000,
+            enableEvents: false,
+            enableLogs: false,
+        });
+        index_1.eventLog.logger.error(logArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(0);
+    });
+    it('should log a debug message', async () => {
+        index_1.eventLog.logger.debug(logArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(1);
+        expect(events[0]).toMatchObject(logArgs);
+    });
+    it('should not log a debug message if logs are disabled', async () => {
+        index_1.eventLog.init({
+            publicApiKey: PUBLIC_API_KEY,
+            batchTime: 1000,
+            enableEvents: false,
+            enableLogs: false,
+        });
+        index_1.eventLog.logger.debug(logArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(0);
+    });
+    it('should log an info message', async () => {
+        index_1.eventLog.logger.info(logArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(1);
+        expect(events[0]).toMatchObject(logArgs);
+    });
+    it('should not log an info message if logs are disabled', async () => {
+        index_1.eventLog.init({
+            publicApiKey: PUBLIC_API_KEY,
+            batchTime: 1000,
+            enableEvents: false,
+            enableLogs: false,
+        });
+        index_1.eventLog.logger.info(logArgs);
+        const events = await database_1.database.getAllItems();
+        expect(events).toHaveLength(0);
+    });
+});

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

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

package/dist/esm/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/esm/index.utils.js

@@ -0,0 +1,12 @@
+"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) {
+    if (!enableLog) {
+        return;
+    }
+    return database_1.database.setItem({ ...logArgs, level, type: types_1.EventLogType.LOG });
+}
+exports.setLog = setLog;

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

@@ -0,0 +1,41 @@
+export declare enum EventLogType {
+    LOG = "LOG",
+    EVENT = "EVENT"
+}
+export declare enum Level {
+    ERROR = "ERROR",
+    DEBUG = "DEBUG",
+    INFO = "INFO"
+}
+type BaseEventLog = {
+    type: EventLogType;
+    customer_session?: string;
+    checkout_session?: string;
+    original_created_at: string;
+};
+export type Log = BaseEventLog & {
+    sdk_version: string;
+    os?: string;
+    url: string;
+    method: string;
+    headers?: object;
+    request?: object;
+    response?: object;
+    status_code?: number;
+    trace_id?: string;
+    metadata?: unknown;
+    country: string;
+    organization_name?: string;
+    level: Level;
+    stack_trace?: string;
+};
+export type Event = BaseEventLog & {
+    source: string;
+    event: string;
+    entity_code?: string;
+    user_email?: string;
+    description: string;
+    headers?: object;
+};
+export type Batch = Log | Event;
+export {};

package/dist/esm/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Level = exports.EventLogType = void 0;
+var EventLogType;
+(function (EventLogType) {
+    EventLogType["LOG"] = "LOG";
+    EventLogType["EVENT"] = "EVENT";
+})(EventLogType || (exports.EventLogType = EventLogType = {}));
+var Level;
+(function (Level) {
+    Level["ERROR"] = "ERROR";
+    Level["DEBUG"] = "DEBUG";
+    Level["INFO"] = "INFO";
+})(Level || (exports.Level = Level = {}));