@chirpier/chirpier-js 0.1.1

package/LICENCE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) Chirpier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,91 @@
+# Chirpier SDK
+
+The Chirpier SDK is a lightweight, versatile library for monitoring and tracking streams of data in both browser and server environments. With built-in retry logic, and offline handling, the Chirpier SDK makes it easy to collect and send data to the Chirpier API.
+
+## Features
+
+- Environment Agnostic: Works seamlessly in both browser and Node.js environments.
+- Retry Logic: Includes retry mechanisms with exponential backoff for failed requests.
+- Offline Support: Queues events when offline and sends them when the connection is restored.
+- Easy Integration: Simple API for quick integration into your projects.
+
+## Installation
+
+You can install the Chirpier SDK via npm:
+```
+npm install @chirpier/sdk
+```
+
+## Getting Started
+
+### Initializing the SDK
+
+To start using the SDK, you need to initialize it with your API key. The SDK works in both browser and Node.js environments.
+
+#### In a Browser
+```
+import { initialize, monitor } from '@chirpier/sdk-js';
+
+// Initialize the SDK with your API key
+initialize({ key: 'your-api-key' });
+
+// Send a data stream tied to a group of streams
+monitor({
+  group_id: '02e4f4d8-415e-4fc1-b01a-677ac5bc9207',
+  stream: 'Sales',
+  value: 15.30,
+});
+```
+
+#### In a Server (e.g., Express.js)
+```
+const express = require('express');
+const { initialize, monitor } = require('@chirpier/sdk-js');
+
+const app = express();
+const port = 3000;
+
+// Initialize the SDK with your API key
+initialize({ key: 'your-api-key' });
+
+app.use(express.json());
+
+app.post('/track-event', (req, res) => {
+  const { group_id, monitor, value } = req.body;
+
+  if (!group_id || !monitor || !value) {
+    return res.status(400).json({ error: 'Missing required fields' });
+  }
+
+  // Monitor an event
+  monitor({ group_id, monitor, value });
+
+  res.status(200).json({ message: 'Event tracked successfully' });
+});
+
+app.listen(port, () => {
+  console.log(`Server is running on http://localhost:${port}`);
+});
+```
+
+## Example
+```
+// Initialize the SDK with your API key
+initialize({ key: 'your-api-key' });
+
+// Monitor an event
+monitor({
+  group_id: 'group UUID',
+  stream: 'Sales',
+  value: 15.3,
+});
+```
+
+## Advanced Usage
+Handling Offline Scenarios
+
+The SDK automatically queues events when the network is unavailable and sends them when the connection is restored.
+
+## Custom Storage Mechanisms
+
+The SDK uses localStorage for browser environments and in memory storage for Node.js. If you need a custom storage mechanism, you can extend the SDK by implementing the Storage interface.

package/dist/__tests__/mocks/server.d.ts

@@ -0,0 +1,2 @@
+export declare function cleanupMockServer(): void;
+//# sourceMappingURL=server.d.ts.map

package/dist/__tests__/mocks/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/__tests__/mocks/server.ts"],"names":[],"mappings":"AAGA,wBAAgB,iBAAiB,SAEhC"}

package/dist/__tests__/mocks/server.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupMockServer = void 0;
+var axios_1 = __importDefault(require("axios"));
+// Cleanup mock server after tests
+function cleanupMockServer() {
+    axios_1.default.defaults.adapter = undefined;
+}
+exports.cleanupMockServer = cleanupMockServer;

package/dist/__tests__/sdk.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};
+//# sourceMappingURL=sdk.test.d.ts.map

package/dist/__tests__/sdk.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/sdk.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/__tests__/sdk.test.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_1 = require("../index");
+var constants_1 = require("../constants");
+var axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+var axios_1 = __importDefault(require("axios"));
+var server_1 = require("./mocks/server");
+describe("Chirpier SDK", function () {
+    var chirpier;
+    afterEach(function () {
+        // Clean up mock server
+        (0, server_1.cleanupMockServer)();
+    });
+    describe("Initialization", function () {
+        test("should initialize with default values", function () {
+            chirpier = new index_1.Chirpier({
+                key: "api_key",
+            });
+            // Setup mock server
+            var mock = new axios_mock_adapter_1.default(axios_1.default);
+            mock.onPost(constants_1.DEFAULT_API_ENDPOINT).reply(200, { success: true });
+            expect(chirpier["apiEndpoint"]).toBe(constants_1.DEFAULT_API_ENDPOINT);
+            expect(chirpier["retries"]).toBe(constants_1.DEFAULT_RETRIES);
+        });
+        test("should initialize with custom values using mock server", function () {
+            chirpier = new index_1.Chirpier({
+                key: "api_key",
+            });
+            // Setup mock server
+            var mock = new axios_mock_adapter_1.default(axios_1.default);
+            mock.onPost(constants_1.DEFAULT_API_ENDPOINT).reply(200, { success: true });
+            var customChirpier = new index_1.Chirpier({
+                key: "api_key",
+                apiEndpoint: constants_1.DEFAULT_API_ENDPOINT,
+                retries: 5,
+            });
+            expect(customChirpier["apiEndpoint"]).toBe(constants_1.DEFAULT_API_ENDPOINT);
+            expect(customChirpier["retries"]).toBe(5);
+        });
+        test("should throw error if key is not provided", function () {
+            chirpier = new index_1.Chirpier({
+                key: "api_key",
+            });
+            // Setup mock server
+            var mock = new axios_mock_adapter_1.default(axios_1.default);
+            mock.onPost(constants_1.DEFAULT_API_ENDPOINT).reply(200, { success: true });
+            expect(function () { return new index_1.Chirpier({}); }).toThrow(index_1.ChirpierError);
+        });
+    });
+    describe("monitor", function () {
+        test("event should be sent", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, event;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chirpier = new index_1.Chirpier({
+                            key: "api_key",
+                        });
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).reply(200, { success: true });
+                        event = {
+                            group_id: "f3438ee9-b964-48aa-b938-a803df440a3c",
+                            stream: "test-stream",
+                            value: 1,
+                        };
+                        return [4 /*yield*/, chirpier.monitor(event)];
+                    case 1:
+                        _a.sent();
+                        // Verify that the event was sent successfully
+                        expect(mock.history.post.length).toBe(1);
+                        expect(mock.history.post[0].url).toBe(constants_1.DEFAULT_API_ENDPOINT);
+                        expect(JSON.parse(mock.history.post[0].data)).toEqual([
+                            {
+                                group_id: "f3438ee9-b964-48aa-b938-a803df440a3c",
+                                stream: "test-stream",
+                                value: 1,
+                                event_id: expect.any(String),
+                            },
+                        ]);
+                        // Clean up the mock
+                        mock.reset();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        // Setup mock server
+        var mock = new axios_mock_adapter_1.default(axios_1.default);
+        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).reply(200, { success: true });
+        test("should throw error for invalid event", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var invalidEvent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chirpier = new index_1.Chirpier({
+                            key: "api_key",
+                        });
+                        invalidEvent = {
+                            group_id: "f3438ee9-b964-48aa-b938-a803df440a3c",
+                        };
+                        return [4 /*yield*/, expect(chirpier.monitor(invalidEvent)).rejects.toThrow(index_1.ChirpierError)];
+                    case 1:
+                        _a.sent();
+                        // Clean up the mock
+                        mock.reset();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_API_ENDPOINT = "https://events.chirpier.co/api/events";
+export declare const DEFAULT_RETRIES = 30;
+export declare const DEFAULT_TIMEOUT = 5000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,0CAA0C,CAAC;AAC5E,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,eAAe,OAAO,CAAA"}

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+// constants.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TIMEOUT = exports.DEFAULT_RETRIES = exports.DEFAULT_API_ENDPOINT = void 0;
+exports.DEFAULT_API_ENDPOINT = 'https://events.chirpier.co/api/events';
+exports.DEFAULT_RETRIES = 30;
+exports.DEFAULT_TIMEOUT = 5000;

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+interface Options {
+    key: string;
+    apiEndpoint?: string;
+    retries?: number;
+    timeout?: number;
+}
+export interface Event {
+    group_id: string;
+    stream: string;
+    value: number;
+    event_id?: string;
+}
+export declare class ChirpierError extends Error {
+    constructor(message: string);
+}
+/**
+ * Main Chirpier class for monitoring events.
+ */
+export declare class Chirpier {
+    private readonly apiKey;
+    private readonly apiEndpoint;
+    private readonly retries;
+    private readonly timeout;
+    private readonly axiosInstance;
+    /**
+     * Initializes a new instance of the Chirpier class.
+     * @param options - Configuration options for the SDK.
+     */
+    constructor({ key, apiEndpoint, retries, timeout, }: Options);
+    /**
+     * Validates the event structure.
+     * @param event - The event to validate.
+     * @returns True if valid, false otherwise.
+     */
+    private isValidEvent;
+    /**
+     * Monitors an event by sending it to the API or storing it for retry.
+     * @param event - The event to monitor.
+     */
+    monitor(event: Event): Promise<void>;
+    /**
+     * Sends an event to the API.
+     * @param event - The event to send.
+     */
+    private sendEvent;
+    /**
+     * Sends multiple events to the API in a batch.
+     * @param events - The array of events to send.
+     */
+    private sendEvents;
+}
+/**
+ * Initializes the Chirpier SDK.
+ * @param options - Configuration options for the SDK.
+ */
+export declare function initialize(options: Options): void;
+/**
+ * Monitors an event using the Chirpier SDK.
+ * @param event - The event to monitor.
+ */
+export declare function monitor(event: Event): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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;CAClB;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;IAE9C;;;OAGG;gBACS,EACV,GAAG,EACH,WAAkC,EAClC,OAAyB,EACzB,OAAyB,GAC1B,EAAE,OAAO;IAuCV;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAUpB;;;OAGG;IACU,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBjD;;;OAGG;YACW,SAAS;IAIvB;;;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"}

package/dist/index.js

@@ -0,0 +1,274 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        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) {
+        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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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;
+// 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");
+// Custom error class for Chirpier-specific errors
+var ChirpierError = /** @class */ (function (_super) {
+    __extends(ChirpierError, _super);
+    function ChirpierError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.name = "ChirpierError";
+        Object.setPrototypeOf(_this, ChirpierError.prototype);
+        return _this;
+    }
+    return ChirpierError;
+}(Error));
+exports.ChirpierError = ChirpierError;
+/**
+ * Main Chirpier class for monitoring events.
+ */
+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;
+        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;
+        // Create axios instance with authorization header
+        this.axiosInstance = axios_1.default.create({
+            headers: { Authorization: "Bearer ".concat(this.apiKey) },
+            timeout: this.timeout,
+        });
+        // Add the interceptor here
+        this.axiosInstance.interceptors.response.use(function (response) { return response; }, function (error) {
+            // Don't handle the error here; let axios-retry handle it
+            return Promise.reject(error);
+        });
+        // Apply axios-retry to your Axios instance
+        (0, axios_retry_1.default)(this.axiosInstance, {
+            retries: this.retries,
+            retryDelay: function (retryCount, error) {
+                return Math.pow(2, retryCount) * 2000; // Exponential backoff starting at 1 second
+            },
+            retryCondition: function (error) {
+                return (axios_retry_1.default.isNetworkError(error) || axios_retry_1.default.isRetryableError(error));
+            },
+            shouldResetTimeout: true,
+        });
+    }
+    /**
+     * Validates the event structure.
+     * @param event - The event to validate.
+     * @returns True if valid, false otherwise.
+     */
+    Chirpier.prototype.isValidEvent = function (event) {
+        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.value === "number");
+    };
+    /**
+     * Monitors an event by sending it to the API or storing it for retry.
+     * @param event - The event to monitor.
+     */
+    Chirpier.prototype.monitor = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var eventWithID, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        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)() });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.sendEvent(eventWithID)];
+                    case 2:
+                        _a.sent();
+                        console.info("Event successfully sent:", eventWithID.event_id);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        console.error("Failed to send event after retries:", error_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Sends an event to the API.
+     * @param event - The event to send.
+     */
+    Chirpier.prototype.sendEvent = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendEvents([event])];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Sends multiple events to the API in a batch.
+     * @param events - The array of events to send.
+     */
+    Chirpier.prototype.sendEvents = function (events) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.post(this.apiEndpoint, events)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Chirpier;
+}());
+exports.Chirpier = Chirpier;
+/**
+ * Decodes a base64url encoded string.
+ * @param str - The base64url encoded string to decode.
+ * @returns The decoded string.
+ */
+function base64UrlDecode(str) {
+    // Replace '-' with '+' and '_' with '/'
+    var base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+    // Pad the base64 string
+    var padding = base64.length % 4;
+    if (padding !== 0) {
+        base64 += "=".repeat(4 - padding);
+    }
+    return js_base64_1.Base64.decode(base64);
+}
+/**
+ * Validates if the provided token is a valid JWT.
+ * @param token - The token to validate.
+ * @returns True if valid, false otherwise.
+ */
+function isValidJWT(token) {
+    var parts = token.split(".");
+    if (parts.length !== 3) {
+        return false;
+    }
+    try {
+        var header = JSON.parse(base64UrlDecode(parts[0]));
+        var payload = JSON.parse(base64UrlDecode(parts[1]));
+        return typeof header === "object" && typeof payload === "object";
+    }
+    catch (error) {
+        return false;
+    }
+}
+// Singleton instance of Chirpier
+var chirpierInstance = null;
+/**
+ * Initializes the Chirpier SDK.
+ * @param options - Configuration options for the SDK.
+ */
+function initialize(options) {
+    if (!isValidJWT(options.key)) {
+        throw new ChirpierError("Invalid API key: Not a valid JWT");
+    }
+    try {
+        chirpierInstance = new Chirpier(options);
+    }
+    catch (error) {
+        if (error instanceof ChirpierError) {
+            console.error("Failed to initialize Chirpier SDK:", error.message);
+        }
+        else {
+            console.error("An unexpected error occurred during Chirpier SDK initialization:", error);
+        }
+        throw error;
+    }
+}
+exports.initialize = initialize;
+/**
+ * Monitors an event using the Chirpier SDK.
+ * @param event - The event to monitor.
+ */
+function monitor(event) {
+    if (!chirpierInstance) {
+        throw new ChirpierError("Chirpier SDK is not initialized. Please call initialize() first.");
+    }
+    chirpierInstance.monitor(event).catch(function (error) {
+        console.error("Error in monitor function:", error);
+    });
+}
+exports.monitor = monitor;

package/dist/storage.d.ts

@@ -0,0 +1,5 @@
+export declare class LocalStorageStorage {
+    save(events: any[]): void;
+    load(): any[];
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAmB;IAC5B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI;IAIzB,IAAI,IAAI,GAAG,EAAE;CAId"}

package/dist/storage.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageStorage = void 0;
+var LocalStorageStorage = /** @class */ (function () {
+    function LocalStorageStorage() {
+    }
+    LocalStorageStorage.prototype.save = function (events) {
+        localStorage.setItem('chirpier_events', JSON.stringify(events));
+    };
+    LocalStorageStorage.prototype.load = function () {
+        var storedEvents = localStorage.getItem('chirpier_events');
+        return storedEvents ? JSON.parse(storedEvents) : [];
+    };
+    return LocalStorageStorage;
+}());
+exports.LocalStorageStorage = LocalStorageStorage;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@chirpier/chirpier-js",
+  "version": "0.1.1",
+  "description": "Chirpier SDK for JavaScript",
+  "keywords": [
+    "chirpier",
+    "sdk",
+    "javascript",
+    "monitoring",
+    "event-tracking"
+  ],
+  "author": "Chirpier",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "types/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build && npm test",
+    "lint": "eslint 'src/**/*.ts'",
+    "test": "jest --coverage"
+  },
+  "dependencies": {
+    "@lukeed/uuid": "^2.0.1",
+    "axios": "^0.24.0",
+    "axios-retry": "^4.5.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "js-base64": "^3.7.7",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.13",
+    "@types/mocha": "^10.0.8",
+    "@types/node": "^22.5.0",
+    "@types/uuid": "^10.0.0",
+    "axios-mock-adapter": "^2.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.4",
+    "typescript": "^4.4.3",
+    "webpack": "^5.52.0",
+    "webpack-cli": "^4.8.0"
+  }
+}

package/src/__tests__/mocks/server.ts

@@ -0,0 +1,6 @@
+import axios from "axios";
+
+// Cleanup mock server after tests
+export function cleanupMockServer() {
+  axios.defaults.adapter = undefined;
+}

package/src/__tests__/sdk.test.ts

@@ -0,0 +1,118 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { Chirpier, ChirpierError, Event } from "../index";
+import { DEFAULT_API_ENDPOINT, DEFAULT_RETRIES } from "../constants";
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { cleanupMockServer } from "./mocks/server";
+
+describe("Chirpier SDK", () => {
+  let chirpier: Chirpier;
+
+  afterEach(() => {
+    // Clean up mock server
+    cleanupMockServer();
+  });
+
+  describe("Initialization", () => {
+    test("should initialize with default values", () => {
+      chirpier = new Chirpier({
+        key: "api_key",
+      });
+
+      // 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);
+    });
+
+    test("should initialize with custom values using mock server", () => {
+      chirpier = new Chirpier({
+        key: "api_key",
+      });
+
+      // Setup mock server
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      const customChirpier = new Chirpier({
+        key: "api_key",
+        apiEndpoint: DEFAULT_API_ENDPOINT,
+        retries: 5,
+      });
+
+      expect(customChirpier["apiEndpoint"]).toBe(DEFAULT_API_ENDPOINT);
+      expect(customChirpier["retries"]).toBe(5);
+    });
+
+    test("should throw error if key is not provided", () => {
+      chirpier = new Chirpier({
+        key: "api_key",
+      });
+
+      // Setup mock server
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      expect(() => new Chirpier({} as any)).toThrow(ChirpierError);
+    });
+  });
+
+  describe("monitor", () => {
+    test("event should be sent", async () => {
+      chirpier = new Chirpier({
+        key: "api_key",
+      });
+
+      // Setup mock server
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+      const event: Event = {
+        group_id: "f3438ee9-b964-48aa-b938-a803df440a3c",
+        stream: "test-stream",
+        value: 1,
+      };
+
+      await chirpier.monitor(event);
+
+      // Verify that the event was sent successfully
+      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: "f3438ee9-b964-48aa-b938-a803df440a3c",
+          stream: "test-stream",
+          value: 1,
+          event_id: expect.any(String),
+        },
+      ]);
+
+      // Clean up the mock
+      mock.reset();
+    });
+
+    // Setup mock server
+    const mock = new MockAdapter(axios);
+    mock.onPost(DEFAULT_API_ENDPOINT).reply(200, { success: true });
+
+    test("should throw error for invalid event", async () => {
+      chirpier = new Chirpier({
+        key: "api_key",
+      });
+      const invalidEvent = {
+        group_id: "f3438ee9-b964-48aa-b938-a803df440a3c",
+      } as any;
+      await expect(chirpier.monitor(invalidEvent)).rejects.toThrow(
+        ChirpierError
+      );
+
+      // Clean up the mock
+      mock.reset();
+    });
+  });
+});

package/src/constants.ts

@@ -0,0 +1,5 @@
+// constants.ts
+
+export const DEFAULT_API_ENDPOINT = 'https://events.chirpier.co/api/events';
+export const DEFAULT_RETRIES = 30;
+export const DEFAULT_TIMEOUT = 5000

package/src/index.ts

@@ -0,0 +1,224 @@
+// Import necessary dependencies
+import axios, { AxiosInstance } from "axios";
+import axiosRetry from "axios-retry";
+import { v4 as uuidv4 } from "@lukeed/uuid";
+import { Base64 } from 'js-base64';
+import {
+  DEFAULT_API_ENDPOINT,
+  DEFAULT_RETRIES,
+  DEFAULT_TIMEOUT,
+} from "./constants";
+
+// Define the options interface for Chirpier initialization
+interface Options {
+  key: string;
+  apiEndpoint?: string;
+  retries?: number;
+  timeout?: number;
+}
+
+// Define the Event interface for monitoring
+export interface Event {
+  group_id: string;
+  stream: string;
+  value: number;
+  event_id?: string;
+}
+
+// Custom error class for Chirpier-specific errors
+export class ChirpierError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ChirpierError";
+    Object.setPrototypeOf(this, ChirpierError.prototype);
+  }
+}
+
+/**
+ * Main Chirpier class for monitoring events.
+ */
+export class Chirpier {
+  private readonly apiKey: string;
+  private readonly apiEndpoint: string;
+  private readonly retries: number;
+  private readonly timeout: number;
+  private readonly axiosInstance: AxiosInstance;
+
+  /**
+   * Initializes a new instance of the Chirpier class.
+   * @param options - Configuration options for the SDK.
+   */
+  constructor({
+    key,
+    apiEndpoint = DEFAULT_API_ENDPOINT,
+    retries = DEFAULT_RETRIES,
+    timeout = DEFAULT_TIMEOUT,
+  }: Options) {
+    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;
+
+    // Create axios instance with authorization header
+    this.axiosInstance = axios.create({
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+      timeout: this.timeout,
+    });
+
+    // Add the interceptor here
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        // Don't handle the error here; let axios-retry handle it
+        return Promise.reject(error);
+      }
+    );
+
+    // Apply axios-retry to your Axios instance
+    axiosRetry(this.axiosInstance, {
+      retries: this.retries,
+      retryDelay: (retryCount, error) => {
+        return Math.pow(2, retryCount) * 2000; // Exponential backoff starting at 1 second
+      },
+      retryCondition: (error) => {
+        return (
+          axiosRetry.isNetworkError(error) || axiosRetry.isRetryableError(error)
+        );
+      },
+      shouldResetTimeout: true,
+    });
+  }
+
+  /**
+   * Validates the event structure.
+   * @param event - The event to validate.
+   * @returns True if valid, false otherwise.
+   */
+  private isValidEvent(event: Event): boolean {
+    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.value === "number"
+    );
+  }
+
+  /**
+   * Monitors an event by sending it to the API or storing it for retry.
+   * @param event - The event to monitor.
+   */
+  public async monitor(event: Event): Promise<void> {
+    if (!this.isValidEvent(event)) {
+      throw new ChirpierError(
+        "Invalid event format. Must include group_id, stream, and numeric value."
+      );
+    }
+
+    // Ensure event_id is only set once
+    const eventWithID = { ...event, event_id: event.event_id || uuidv4() };
+
+    try {
+      await this.sendEvent(eventWithID);
+      console.info("Event successfully sent:", eventWithID.event_id);
+    } catch (error) {
+      console.error("Failed to send event after retries:", error);
+    }
+  }
+
+  /**
+   * Sends an event to the API.
+   * @param event - The event to send.
+   */
+  private async sendEvent(event: Event): Promise<void> {
+    await this.sendEvents([event]);
+  }
+
+  /**
+   * Sends multiple events to the API in a batch.
+   * @param events - The array of events to send.
+   */
+  private async sendEvents(events: Event[]): Promise<void> {
+    await this.axiosInstance.post(this.apiEndpoint, events);
+  }
+}
+
+/**
+ * Decodes a base64url encoded string.
+ * @param str - The base64url encoded string to decode.
+ * @returns The decoded string.
+ */
+function base64UrlDecode(str: string): string {
+  // Replace '-' with '+' and '_' with '/'
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  // Pad the base64 string
+  const padding = base64.length % 4;
+  if (padding !== 0) {
+    base64 += "=".repeat(4 - padding);
+  }
+  return Base64.decode(base64);
+}
+
+/**
+ * Validates if the provided token is a valid JWT.
+ * @param token - The token to validate.
+ * @returns True if valid, false otherwise.
+ */
+function isValidJWT(token: string): boolean {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return false;
+  }
+  try {
+    const header = JSON.parse(base64UrlDecode(parts[0]));
+    const payload = JSON.parse(base64UrlDecode(parts[1]));
+    return typeof header === "object" && typeof payload === "object";
+  } catch (error) {
+    return false;
+  }
+}
+
+// Singleton instance of Chirpier
+let chirpierInstance: Chirpier | null = null;
+
+/**
+ * Initializes the Chirpier SDK.
+ * @param options - Configuration options for the SDK.
+ */
+export function initialize(options: Options): void {
+  if (!isValidJWT(options.key)) {
+    throw new ChirpierError("Invalid API key: Not a valid JWT");
+  }
+
+  try {
+    chirpierInstance = new Chirpier(options);
+  } catch (error) {
+    if (error instanceof ChirpierError) {
+      console.error("Failed to initialize Chirpier SDK:", error.message);
+    } else {
+      console.error(
+        "An unexpected error occurred during Chirpier SDK initialization:",
+        error
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * Monitors an event using the Chirpier SDK.
+ * @param event - The event to monitor.
+ */
+export function monitor(event: Event): void {
+  if (!chirpierInstance) {
+    throw new ChirpierError(
+      "Chirpier SDK is not initialized. Please call initialize() first."
+    );
+  }
+  chirpierInstance.monitor(event).catch((error) => {
+    console.error("Error in monitor function:", error);
+  });
+}

package/src/storage.ts

@@ -0,0 +1,10 @@
+export class LocalStorageStorage {
+    save(events: any[]): void {
+      localStorage.setItem('chirpier_events', JSON.stringify(events));
+    }
+  
+    load(): any[] {
+      const storedEvents = localStorage.getItem('chirpier_events');
+      return storedEvents ? JSON.parse(storedEvents) : [];
+    }
+  }