@yuno-payments/sdk-event-log 0.2.0

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

@@ -0,0 +1,51 @@
+"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");
+    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");
+    }
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
+        });
+    }
+    setItem(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            __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/cjs/database/memory-storage/memory-storage.test.d.ts

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

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

@@ -0,0 +1,34 @@
+"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());
+    });
+};
+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', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield memoryStorage.setItem(batch);
+        const database = yield memoryStorage.getAllItems();
+        expect(database).toEqual([batch]);
+    }));
+});

package/dist/cjs/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/cjs/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(Object.assign(Object.assign({}, eventArgs), { type: types_1.EventLogType.EVENT }));
+    }
+}
+_EventLog_enableEvents = new WeakMap(), _EventLog_enableLogs = new WeakMap();
+exports.eventLog = new EventLog();

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

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

package/dist/cjs/index.test.js

@@ -0,0 +1,113 @@
+"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());
+    });
+};
+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(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield new Promise((resolve) => setTimeout(resolve, 1000));
+        cron_1.cron.stop();
+    }));
+    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);
+        const events = yield database_1.database.getAllItems();
+        expect(events).toHaveLength(1);
+        expect(events[0]).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);
+    }));
+});

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

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

package/dist/cjs/index.types.js

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

package/dist/cjs/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/cjs/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(Object.assign(Object.assign({}, logArgs), { level, type: types_1.EventLogType.LOG }));
+}
+exports.setLog = setLog;

package/dist/cjs/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/cjs/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 = {}));

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const api_1 = require("../api");
+const PUBLIC_API_KEY = 'staging_gAAAAABj-NC2WEf3XA4lHnN6RfGbjETf6qL27jlU7c1tm01ERV-Y-E6ddee1QPyV_CA8cxjVlGy-qDNA2-mqa9msQlTJit-Fmbvv6f2AZdfbFd_CUo1stvixnF4_8MzM_IYVWYz7KK86VfEBvxNpjRCyp7BDef-QzrT1-yqa8HAYTuA1GU3Hjjo=';
+const publicApiKey = PUBLIC_API_KEY;
+const platform = 'web';
+const STATUS_CREATED = 201;
+describe('Api', () => {
+    beforeEach(() => {
+        // Reset the instance before each test
+        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_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', async () => {
+        const batches = [
+            {
+                source: 'test',
+                event: 'testEvent',
+                description: 'Test event',
+                original_created_at: new Date().toISOString(),
+                type: types_1.EventLogType.EVENT,
+            },
+        ];
+        const response = await 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_1.api.getInstances();
+        expect(instance).not.toBeNull();
+    });
+});

package/dist/esm/api/__tests__/api.utils.test.d.ts

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

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_utils_1 = require("../api.utils");
+describe('getBaseUrl', () => {
+    it('should return the correct base URL for a dev environment', () => {
+        const publicApiKey = 'dev_1234567890';
+        const expectedUrl = 'https://api-dev.y.uno/v1';
+        const result = (0, api_utils_1.getBaseUrl)(publicApiKey);
+        expect(result).toBe(expectedUrl);
+    });
+    it('should return the correct base URL for a staging environment', () => {
+        const publicApiKey = 'staging_1234567890';
+        const expectedUrl = 'https://api-staging.y.uno/v1';
+        const result = (0, api_utils_1.getBaseUrl)(publicApiKey);
+        expect(result).toBe(expectedUrl);
+    });
+    it('should return the correct base URL for a sandbox environment', () => {
+        const publicApiKey = 'sandbox_1234567890';
+        const expectedUrl = 'https://api-sandbox.y.uno/v1';
+        const result = (0, api_utils_1.getBaseUrl)(publicApiKey);
+        expect(result).toBe(expectedUrl);
+    });
+    it('should return the correct base URL for a prod environment', () => {
+        const publicApiKey = 'prod_1234567890';
+        const expectedUrl = 'https://api.y.uno/v1';
+        const result = (0, api_utils_1.getBaseUrl)(publicApiKey);
+        expect(result).toBe(expectedUrl);
+    });
+    it('should throw an error for an invalid public API key', () => {
+        const publicApiKey = 'invalidApiKey';
+        expect(() => {
+            (0, api_utils_1.getBaseUrl)(publicApiKey);
+        }).toThrowError('Not environment found publicApiKey: invalidApiKey, apiKeyPrefix: invalidApiKey, environmentSuffix: undefined');
+    });
+});

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

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

package/dist/esm/api/api.js

@@ -0,0 +1,41 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Api_instance;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
+const axios_1 = __importDefault(require("axios"));
+const api_utils_1 = require("./api.utils");
+class Api {
+    constructor() {
+        _Api_instance.set(this, null);
+    }
+    init(publicApiKey, platform) {
+        __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 },
+        }), "f");
+    }
+    sendBatch(batches) {
+        var _a;
+        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");
+    }
+}
+_Api_instance = new WeakMap();
+exports.api = new Api();

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

@@ -0,0 +1 @@
+export declare const getBaseUrl: (publicApiKey: string) => string;

package/dist/esm/api/api.utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseUrl = void 0;
+const ApiKeyPrefixToEnvironmentSuffix = {
+    dev: '-dev',
+    staging: '-staging',
+    sandbox: '-sandbox',
+    prod: '',
+};
+const getBaseUrl = (publicApiKey) => {
+    const [apiKeyPrefix] = publicApiKey.split('_');
+    const environmentSuffix = ApiKeyPrefixToEnvironmentSuffix[apiKeyPrefix];
+    if (environmentSuffix === undefined) {
+        throw new Error(`Not environment found publicApiKey: ${publicApiKey}, apiKeyPrefix: ${apiKeyPrefix}, environmentSuffix: ${environmentSuffix}`);
+    }
+    return 'https://api_ENVIRONMENT_.y.uno/v1'.replace('_ENVIRONMENT_', environmentSuffix);
+};
+exports.getBaseUrl = getBaseUrl;

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

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

package/dist/esm/api/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("./api"), exports);

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

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

package/dist/esm/cron/cron.js

@@ -0,0 +1,46 @@
+"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 _Cron_interval;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cron = void 0;
+const api_1 = require("../api");
+const database_1 = require("../database");
+const NONE_ITEMS = 0;
+class Cron {
+    constructor() {
+        _Cron_interval.set(this, void 0);
+    }
+    init(batchTime) {
+        this.stop();
+        __classPrivateFieldSet(this, _Cron_interval, setInterval(this.sendBatch, batchTime), "f");
+    }
+    sendBatch() {
+        database_1.database.getAllItems().then((items) => {
+            var _a;
+            if (items.length > NONE_ITEMS) {
+                (_a = api_1.api.sendBatch(items)) === null || _a === void 0 ? void 0 : _a.then(() => database_1.database.reset());
+            }
+        });
+    }
+    stop() {
+        if (__classPrivateFieldGet(this, _Cron_interval, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _Cron_interval, "f"));
+            __classPrivateFieldSet(this, _Cron_interval, undefined, "f");
+        }
+    }
+    getInterval() {
+        return __classPrivateFieldGet(this, _Cron_interval, "f");
+    }
+}
+_Cron_interval = new WeakMap();
+exports.cron = new Cron();

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cron_1 = require("./cron");
+const api_1 = require("../api");
+const database_1 = require("../database");
+const types_1 = require("../types");
+const TIME_INTERVAL = 1000;
+describe('Cron', () => {
+    let spy;
+    beforeEach(async () => {
+        // restore the spy created with spyOn
+        jest.restoreAllMocks();
+        spy = jest.spyOn(api_1.api, 'sendBatch');
+        await database_1.database.reset();
+    });
+    it('should send a batch of items to the API if there are items in the database', async () => {
+        const batch = {
+            source: 'test',
+            event: 'testEvent',
+            description: 'Test event',
+            original_created_at: new Date().toISOString(),
+            type: types_1.EventLogType.EVENT,
+        };
+        database_1.database.setItem(batch);
+        await 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', async () => {
+        await cron_1.cron.sendBatch();
+        expect(spy).not.toHaveBeenCalled();
+    });
+    it('should stop the interval when stop is called', () => {
+        jest.useFakeTimers();
+        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();
+        cron_1.cron.init(TIME_INTERVAL);
+        expect(cron_1.cron.getInterval()).toBeDefined();
+    });
+});

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

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