@chirpier/chirpier-js 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,16 +1,17 @@
+export declare enum LogLevel {
+    None = 0,
+    Error = 1,
+    Info = 2,
+    Debug = 3
+}
 interface Options {
     key: string;
-    apiEndpoint?: string;
-    retries?: number;
-    timeout?: number;
-    batchSize?: number;
-    flushInterval?: number;
+    logLevel?: LogLevel;
 }
 export interface Event {
     group_id: string;
-    stream: string;
+    stream_name: string;
     value: number;
-    event_id?: string;
 }
 export declare class ChirpierError extends Error {
     constructor(message: string);
@@ -19,20 +20,30 @@ export declare class ChirpierError extends Error {
  * Main Chirpier class for monitoring events.
  */
 export declare class Chirpier {
+    private static instance;
     private readonly apiKey;
     private readonly apiEndpoint;
     private readonly retries;
     private readonly timeout;
     private readonly axiosInstance;
     private eventQueue;
-    private flushTimeout;
     private readonly batchSize;
-    private readonly flushInterval;
+    private readonly flushDelay;
+    private flushTimeoutId;
+    private readonly queueLock;
+    private readonly flushLock;
+    private readonly logLevel;
     /**
      * Initializes a new instance of the Chirpier class.
      * @param options - Configuration options for the SDK.
      */
-    constructor({ key, apiEndpoint, retries, timeout, batchSize, flushInterval, }: Options);
+    private constructor();
+    /**
+     * Gets the singleton instance of Chirpier, creating it if it doesn't exist.
+     * @param options - Configuration options for the SDK.
+     * @returns The Chirpier instance.
+     */
+    static getInstance(options: Options): Chirpier | null;
     /**
      * Validates the event structure.
      * @param event - The event to validate.
@@ -53,6 +64,7 @@ export declare class Chirpier {
      * @param events - The array of events to send.
      */
     private sendEvents;
+    static stop(): Promise<void>;
 }
 /**
  * Initializes the Chirpier SDK.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,UAAU,OAAO;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAGD,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAGD,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAK5B;AAED;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;;OAGG;gBACS,EACV,GAAG,EACH,WAAkC,EAClC,OAAyB,EACzB,OAAyB,EACzB,SAAe,EACf,aAAmB,GACpB,EAAE,OAAO;IAyCV;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAapB;;;OAGG;IACU,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BjD;;OAEG;YACW,UAAU;IA6BxB;;;OAGG;YACW,UAAU;CAGzB;AAwCD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkBjD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAS1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,oBAAY,QAAQ;IAClB,IAAI,IAAI;IACR,KAAK,IAAI;IACT,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAGD,UAAU,OAAO;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAGD,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAGD,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAK5B;AAQD;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IAEpC;;;OAGG;IACH,OAAO;IA6CP;;;;OAIG;WACW,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI;IAO5D;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAapB;;;OAGG;IACU,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBjD;;OAEG;YACW,UAAU;IA8DxB;;;OAGG;YACW,UAAU;WAKJ,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAa1C;AAqCD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsBjD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAW1C"}

package/dist/index.js

@@ -14,17 +14,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -74,13 +63,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.monitor = exports.initialize = exports.Chirpier = exports.ChirpierError = void 0;
+exports.monitor = exports.initialize = exports.Chirpier = exports.ChirpierError = exports.LogLevel = void 0;
 // Import necessary dependencies
 var axios_1 = __importDefault(require("axios"));
 var axios_retry_1 = __importDefault(require("axios-retry"));
-var uuid_1 = require("@lukeed/uuid");
 var js_base64_1 = require("js-base64");
 var constants_1 = require("./constants");
+var async_lock_1 = __importDefault(require("async-lock"));
+// Define logging levels
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["None"] = 0] = "None";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Info"] = 2] = "Info";
+    LogLevel[LogLevel["Debug"] = 3] = "Debug";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
 // Custom error class for Chirpier-specific errors
 var ChirpierError = /** @class */ (function (_super) {
     __extends(ChirpierError, _super);
@@ -101,19 +98,22 @@ var Chirpier = /** @class */ (function () {
      * Initializes a new instance of the Chirpier class.
      * @param options - Configuration options for the SDK.
      */
-    function Chirpier(_a) {
-        var key = _a.key, _b = _a.apiEndpoint, apiEndpoint = _b === void 0 ? constants_1.DEFAULT_API_ENDPOINT : _b, _c = _a.retries, retries = _c === void 0 ? constants_1.DEFAULT_RETRIES : _c, _d = _a.timeout, timeout = _d === void 0 ? constants_1.DEFAULT_TIMEOUT : _d, _e = _a.batchSize, batchSize = _e === void 0 ? 100 : _e, _f = _a.flushInterval, flushInterval = _f === void 0 ? 500 : _f;
+    function Chirpier(options) {
         this.eventQueue = [];
-        this.flushTimeout = null;
+        this.flushTimeoutId = null;
+        this.queueLock = new async_lock_1.default();
+        this.flushLock = new async_lock_1.default();
+        var key = options.key, _a = options.logLevel, logLevel = _a === void 0 ? LogLevel.None : _a;
         if (!key || typeof key !== "string") {
             throw new ChirpierError("API key is required and must be a string");
         }
         this.apiKey = key;
-        this.apiEndpoint = apiEndpoint;
-        this.retries = retries;
-        this.timeout = timeout;
-        this.batchSize = batchSize;
-        this.flushInterval = flushInterval;
+        this.apiEndpoint = constants_1.DEFAULT_API_ENDPOINT;
+        this.retries = constants_1.DEFAULT_RETRIES;
+        this.timeout = constants_1.DEFAULT_TIMEOUT;
+        this.batchSize = constants_1.DEFAULT_BATCH_SIZE;
+        this.flushDelay = constants_1.DEFAULT_FLUSH_DELAY;
+        this.logLevel = logLevel;
         // Create axios instance with authorization header
         this.axiosInstance = axios_1.default.create({
             headers: { Authorization: "Bearer ".concat(this.apiKey) },
@@ -136,6 +136,17 @@ var Chirpier = /** @class */ (function () {
             shouldResetTimeout: true,
         });
     }
+    /**
+     * Gets the singleton instance of Chirpier, creating it if it doesn't exist.
+     * @param options - Configuration options for the SDK.
+     * @returns The Chirpier instance.
+     */
+    Chirpier.getInstance = function (options) {
+        if (!Chirpier.instance && options.key) {
+            Chirpier.instance = new Chirpier(options);
+        }
+        return Chirpier.instance;
+    };
     /**
      * Validates the event structure.
      * @param event - The event to validate.
@@ -145,8 +156,8 @@ var Chirpier = /** @class */ (function () {
         return (typeof event.group_id === "string" &&
             /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(event.group_id) &&
             event.group_id.trim().length > 0 &&
-            typeof event.stream === "string" &&
-            event.stream.trim().length > 0 &&
+            typeof event.stream_name === "string" &&
+            event.stream_name.trim().length > 0 &&
             typeof event.value === "number");
     };
     /**
@@ -155,24 +166,36 @@ var Chirpier = /** @class */ (function () {
      */
     Chirpier.prototype.monitor = function (event) {
         return __awaiter(this, void 0, void 0, function () {
-            var eventWithID;
             var _this = this;
             return __generator(this, function (_a) {
-                if (!this.apiKey) {
-                    throw new ChirpierError("Chirpier SDK must be initialized before calling monitor()");
-                }
-                if (!this.isValidEvent(event)) {
-                    throw new ChirpierError("Invalid event format. Must include group_id, stream, and numeric value.");
-                }
-                eventWithID = __assign(__assign({}, event), { event_id: event.event_id || (0, uuid_1.v4)() });
-                this.eventQueue.push(eventWithID);
-                if (this.eventQueue.length >= this.batchSize) {
-                    this.flushQueue();
-                }
-                else if (!this.flushTimeout) {
-                    this.flushTimeout = setTimeout(function () { return _this.flushQueue(); }, this.flushInterval);
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isValidEvent(event)) {
+                            throw new ChirpierError("Invalid event format. Must include group_id, stream_name, and numeric value.");
+                        }
+                        return [4 /*yield*/, this.queueLock.acquire("queue", function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    if (this.eventQueue.length >= constants_1.MAX_QUEUE_SIZE) {
+                                        throw new ChirpierError("Event queue is full.");
+                                    }
+                                    this.eventQueue.push({ event: event, timestamp: Date.now(), retryCount: 0 });
+                                    return [2 /*return*/];
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        if (!(this.eventQueue.length >= this.batchSize)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.flushQueue()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        if (!this.flushTimeoutId) {
+                            this.flushTimeoutId = setTimeout(function () { return _this.flushQueue(); }, this.flushDelay);
+                        }
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
                 }
-                return [2 /*return*/];
             });
         });
     };
@@ -181,37 +204,88 @@ var Chirpier = /** @class */ (function () {
      */
     Chirpier.prototype.flushQueue = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var eventsToSend, error_1;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (this.eventQueue.length === 0) {
-                            return [2 /*return*/];
-                        }
-                        if (this.flushTimeout) {
-                            clearTimeout(this.flushTimeout);
-                            this.flushTimeout = null;
-                        }
-                        eventsToSend = __spreadArray([], this.eventQueue, true);
-                        this.eventQueue = [];
-                        _a.label = 1;
+                    case 0: 
+                    // Acquire the flush lock
+                    return [4 /*yield*/, this.flushLock.acquire("flush", function () { return __awaiter(_this, void 0, void 0, function () {
+                            var eventsToSend, error_1, retryableEvents_1, _i, eventsToSend_1, queuedEvent;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        eventsToSend = [];
+                                        // Extract events from the queue under the queue lock
+                                        return [4 /*yield*/, this.queueLock.acquire("eventQueue", function () { return __awaiter(_this, void 0, void 0, function () {
+                                                return __generator(this, function (_a) {
+                                                    if (this.eventQueue.length > 0) {
+                                                        eventsToSend = __spreadArray([], this.eventQueue, true);
+                                                        this.eventQueue = [];
+                                                    }
+                                                    return [2 /*return*/];
+                                                });
+                                            }); })];
+                                    case 1:
+                                        // Extract events from the queue under the queue lock
+                                        _a.sent();
+                                        if (eventsToSend.length === 0) {
+                                            return [2 /*return*/];
+                                        }
+                                        _a.label = 2;
+                                    case 2:
+                                        _a.trys.push([2, 4, , 6]);
+                                        // Clear any pending flush timeout
+                                        if (this.flushTimeoutId) {
+                                            clearTimeout(this.flushTimeoutId);
+                                            this.flushTimeoutId = null;
+                                        }
+                                        // Attempt to send events
+                                        return [4 /*yield*/, this.sendEvents(eventsToSend.map(function (qe) { return qe.event; }))];
+                                    case 3:
+                                        // Attempt to send events
+                                        _a.sent();
+                                        if (this.logLevel >= LogLevel.Info) {
+                                            console.info("Successfully sent ".concat(eventsToSend.length, " events"));
+                                        }
+                                        return [3 /*break*/, 6];
+                                    case 4:
+                                        error_1 = _a.sent();
+                                        // Log failure
+                                        if (this.logLevel >= LogLevel.Error) {
+                                            console.error("Failed to send events:", error_1);
+                                        }
+                                        retryableEvents_1 = [];
+                                        for (_i = 0, eventsToSend_1 = eventsToSend; _i < eventsToSend_1.length; _i++) {
+                                            queuedEvent = eventsToSend_1[_i];
+                                            if (queuedEvent.retryCount >= this.retries) {
+                                                if (this.logLevel >= LogLevel.Error) {
+                                                    console.error("Dropping event after ".concat(this.retries, " retries:"), queuedEvent.event);
+                                                }
+                                                continue; // Skip adding this event back to the queue
+                                            }
+                                            // Increment retry count and add back to the queue
+                                            queuedEvent.retryCount++;
+                                            retryableEvents_1.push(queuedEvent);
+                                        }
+                                        // Requeue remaining retryable events
+                                        return [4 /*yield*/, this.queueLock.acquire("eventQueue", function () { return __awaiter(_this, void 0, void 0, function () {
+                                                return __generator(this, function (_a) {
+                                                    this.eventQueue = __spreadArray(__spreadArray([], retryableEvents_1, true), this.eventQueue, true);
+                                                    return [2 /*return*/];
+                                                });
+                                            }); })];
+                                    case 5:
+                                        // Requeue remaining retryable events
+                                        _a.sent();
+                                        return [3 /*break*/, 6];
+                                    case 6: return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.sendEvents(eventsToSend)];
-                    case 2:
+                        // Acquire the flush lock
                         _a.sent();
-                        console.info("Successfully sent ".concat(eventsToSend.length, " events"));
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        console.error("Failed to send events:", error_1);
-                        return [3 /*break*/, 4];
-                    case 4:
-                        // Schedule next flush if there are more events
-                        if (this.eventQueue.length > 0) {
-                            this.flushTimeout = setTimeout(function () { return _this.flushQueue(); }, this.flushInterval);
-                        }
                         return [2 /*return*/];
                 }
             });
@@ -233,6 +307,32 @@ var Chirpier = /** @class */ (function () {
             });
         });
     };
+    // Stop the timeout and uninitialize the Chirpier instance
+    Chirpier.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Chirpier.instance) {
+                            return [2 /*return*/];
+                        }
+                        if (Chirpier.instance.flushTimeoutId) {
+                            clearTimeout(Chirpier.instance.flushTimeoutId);
+                            Chirpier.instance.flushTimeoutId = null;
+                        }
+                        // Flush any remaining events in the queue
+                        return [4 /*yield*/, Chirpier.instance.flushQueue()];
+                    case 1:
+                        // Flush any remaining events in the queue
+                        _a.sent();
+                        // Uninitialize the Chirpier instance
+                        Chirpier.instance = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Chirpier.instance = null;
     return Chirpier;
 }());
 exports.Chirpier = Chirpier;
@@ -270,8 +370,6 @@ function isValidJWT(token) {
         return false;
     }
 }
-// Singleton instance of Chirpier
-var chirpierInstance = null;
 /**
  * Initializes the Chirpier SDK.
  * @param options - Configuration options for the SDK.
@@ -281,14 +379,18 @@ function initialize(options) {
         throw new ChirpierError("Invalid API key: Not a valid JWT");
     }
     try {
-        chirpierInstance = new Chirpier(options);
+        Chirpier.getInstance(options);
     }
     catch (error) {
         if (error instanceof ChirpierError) {
-            console.error("Failed to initialize Chirpier SDK:", error.message);
+            if (options.logLevel && options.logLevel >= LogLevel.Error) {
+                console.error("Failed to initialize Chirpier SDK:", error.message);
+            }
         }
         else {
-            console.error("An unexpected error occurred during Chirpier SDK initialization:", error);
+            if (options.logLevel && options.logLevel >= LogLevel.Error) {
+                console.error("An unexpected error occurred during Chirpier SDK initialization:", error);
+            }
         }
         throw error;
     }
@@ -299,10 +401,11 @@ exports.initialize = initialize;
  * @param event - The event to monitor.
  */
 function monitor(event) {
-    if (!chirpierInstance) {
+    var instance = Chirpier.getInstance({});
+    if (!instance) {
         throw new ChirpierError("Chirpier SDK is not initialized. Please call initialize() first.");
     }
-    chirpierInstance.monitor(event).catch(function (error) {
+    instance.monitor(event).catch(function (error) {
         console.error("Error in monitor function:", error);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chirpier/chirpier-js",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Chirpier SDK for JavaScript",
   "keywords": [
     "chirpier",
@@ -27,7 +27,7 @@
     "test": "jest --coverage"
   },
   "dependencies": {
-    "@lukeed/uuid": "^2.0.1",
+    "async-lock": "^1.4.1",
     "axios": "^0.24.0",
     "axios-retry": "^4.5.0",
     "js-base64": "^3.7.7",
@@ -35,15 +35,20 @@
     "tslib": "^2.3.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.15.0",
     "@jest/globals": "^29.7.0",
+    "@types/async-lock": "^1.4.2",
     "@types/jest": "^29.5.13",
     "@types/mocha": "^10.0.8",
     "@types/node": "^22.7.5",
     "@types/uuid": "^10.0.0",
     "axios-mock-adapter": "^2.0.0",
+    "eslint": "^9.15.0",
+    "globals": "^15.12.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.4",
     "typescript": "^4.4.3",
+    "typescript-eslint": "^8.15.0",
     "webpack": "^5.52.0",
     "webpack-cli": "^4.8.0"
   }

package/src/__tests__/chirpier.test.ts

@@ -0,0 +1,170 @@
+import { Chirpier, ChirpierError, Event, LogLevel, initialize, monitor } from "../index";
+import {
+  DEFAULT_API_ENDPOINT,
+  DEFAULT_RETRIES,
+  DEFAULT_TIMEOUT,
+  DEFAULT_BATCH_SIZE,
+  DEFAULT_FLUSH_DELAY,
+} from "../constants";
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+
+describe("Chirpier SDK", () => {
+  describe("Initialization", () => {
+    test("should throw error if monitor is called before initialize", () => {
+      const event: Event = {
+        group_id: "bfd9299d-817a-452f-bc53-6e154f2281fc",
+        stream_name: "test-stream",
+        value: 1,
+      };
+
+      expect(() => monitor(event)).toThrow(ChirpierError);
+      expect(() => monitor(event)).toThrow(
+        "Chirpier SDK is not initialized. Please call initialize() first."
+      );
+    });
+
+    test("should initialize with default values", () => {
+      initialize({
+        key: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+        logLevel: LogLevel.None
+      });
+      const chirpier = Chirpier.getInstance({} as any);
+
+      // Setup mock server
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      expect(chirpier?.["apiEndpoint"]).toBe(DEFAULT_API_ENDPOINT);
+      expect(chirpier?.["retries"]).toBe(DEFAULT_RETRIES);
+      expect(chirpier?.["timeout"]).toBe(DEFAULT_TIMEOUT);
+      expect(chirpier?.["batchSize"]).toBe(DEFAULT_BATCH_SIZE);
+      expect(chirpier?.["flushDelay"]).toBe(DEFAULT_FLUSH_DELAY);
+
+      Chirpier.stop();
+    });
+
+    test("should throw error if key is not provided", () => {
+      expect(() => {
+        initialize({
+          key: "api_key",
+          logLevel: LogLevel.None
+        });
+      }).toThrow(ChirpierError);
+      expect(() => {
+        initialize({
+          key: "api_key",
+          logLevel: LogLevel.None
+        });
+      }).toThrow("Invalid API key: Not a valid JWT");
+    });
+  });
+
+  describe("monitor", () => {
+    test("event should be sent", async () => {
+      // Setup mock server
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      initialize({
+        key: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+        logLevel: LogLevel.None
+      });
+
+      const event: Event = {
+        group_id: "bfd9299d-817a-452f-bc53-6e154f2281fc",
+        stream_name: "test-stream",
+        value: 1,
+      };
+
+      monitor(event);
+
+      await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait for flush
+
+      expect(mock.history.post.length).toBe(1);
+      expect(mock.history.post[0].url).toBe(DEFAULT_API_ENDPOINT);
+      expect(JSON.parse(mock.history.post[0].data)).toEqual([
+        {
+          group_id: "bfd9299d-817a-452f-bc53-6e154f2281fc",
+          stream_name: "test-stream",
+          value: 1,
+        },
+      ]);
+
+      // Clean up the mock
+      mock.reset();
+      Chirpier.stop();
+    });
+
+    test("should throw error for invalid event", async () => {
+      initialize({
+        key: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+        logLevel: LogLevel.None
+      });
+      const chirpier = Chirpier.getInstance({} as any);
+
+      const invalidEvent = {
+        group_id: "bfd9299d-817a-452f-bc53-6e154f2281fc",
+      } as any;
+      await expect(chirpier?.monitor(invalidEvent)).rejects.toThrow(
+        ChirpierError
+      );
+
+      // Clean up the mock
+      Chirpier.stop();
+    });
+
+    test("should batch events and flush when batch size is reached", async () => {
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      initialize({
+        key: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+        logLevel: LogLevel.None
+      });
+
+      const event: Event = {
+        group_id: "bfd9299d-817a-452f-bc53-6e154f2281fc",
+        stream_name: "test-stream",
+        value: 1,
+      };
+
+      monitor(event);
+      monitor(event);
+
+      await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait for flush
+
+      expect(mock.history.post.length).toBe(1);
+      expect(JSON.parse(mock.history.post[0].data).length).toBe(2);
+
+      mock.reset();
+      Chirpier.stop();
+    });
+
+    test("should flush events after interval", async () => {
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      initialize({
+        key: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+        logLevel: LogLevel.None
+      });
+
+      const event: Event = {
+        group_id: "bfd9299d-817a-452f-bc53-6e154f2281fc",
+        stream_name: "test-stream",
+        value: 1,
+      };
+
+      monitor(event);
+
+      await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait for flush
+
+      expect(mock.history.post.length).toBe(1);
+      expect(JSON.parse(mock.history.post[0].data).length).toBe(1);
+
+      mock.reset();
+      Chirpier.stop();
+    });
+  });
+});

package/src/constants.ts

@@ -1,5 +1,8 @@
 // constants.ts
 
-export const DEFAULT_API_ENDPOINT = 'https://events.chirpier.co/api/events';
-export const DEFAULT_RETRIES = 30;
-export const DEFAULT_TIMEOUT = 5000
+export const DEFAULT_API_ENDPOINT = 'https://events.chirpier.co/v1.0/events';
+export const DEFAULT_RETRIES = 15;
+export const DEFAULT_TIMEOUT = 5000
+export const DEFAULT_BATCH_SIZE = 100;
+export const DEFAULT_FLUSH_DELAY = 500;
+export const MAX_QUEUE_SIZE = 2000;