@chirpier/chirpier-js 0.2.1 → 0.4.0

package/README.md

@@ -76,6 +76,11 @@ Default servicer endpoint is `https://api.chirpier.co/v1.0`.
 The same bearer token is used for both ingest and servicer APIs.
 Queued logs are not dropped locally because of queue capacity or retry exhaustion.
 
+### Retry behavior
+
+The SDK retries network/transport failures, `429` responses, and retryable `5xx` responses such as `502` and `504`.
+It does not retry `401`, `403`, `404`, `500`, or `503`, and `401`/`403` errors surface the Chirpier response message when available.
+
 ### `logEvent(log)`
 
 Queues a log for batched delivery.
@@ -124,6 +129,7 @@ Client methods:
 - `client.close()`: Alias of `client.shutdown()`.
 - `client.listEvents()`: List event definitions using the servicer API.
 - `client.getEvent(eventID)`: Read one event definition.
+- `client.getEventAnalytics(eventID, query)`: Read analytics window comparisons.
 - `client.updateEvent(eventID, payload)`: Update event definition metadata.
 - `client.listPolicies()`: List monitors/policies.
 - `client.createPolicy(payload)`: Create a monitor/policy.
@@ -132,7 +138,7 @@ Client methods:
 - `client.acknowledgeAlert(alertID)`: Acknowledge an alert.
 - `client.resolveAlert(alertID)`: Resolve an alert.
 - `client.archiveAlert(alertID)`: Archive an alert.
-- `client.testWebhook(webhookID)`: Send a connector test message.
+- `client.testDestination(destinationID)`: Send a destination test and return the synthetic test `alert_id`.
 - `client.getEventLogs(eventID, { period, limit, offset })`: Read minute/hour/day event rollups.
 <!-- docs:end common-tasks -->
 
@@ -155,10 +161,20 @@ await client.log({
   meta: { task_name: "daily_digest" },
 });
 
+await client.flush();
+
 const events = await client.listEvents();
-const toolErrors = events.find((eventDef) => eventDef.event === "tool.errors.count");
+const toolErrors = events.find(
+  (eventDef) => eventDef.agent === "openclaw.main" && eventDef.event === "tool.errors.count"
+);
 
 if (toolErrors) {
+  const analytics = await client.getEventAnalytics(toolErrors.event_id, {
+    view: "window",
+    period: "1h",
+    previous: "previous_window",
+  });
+
   await client.createPolicy({
     event_id: toolErrors.event_id,
     title: "OpenClaw tool errors spike",
@@ -172,6 +188,17 @@ if (toolErrors) {
   });
 
   await client.getEventLogs(toolErrors.event_id, { period: "hour", limit: 24 });
+
+  const destination = await client.createDestination({
+    channel: "slack",
+    url: "https://hooks.slack.com/services/T000/B000/secret",
+    scope: "all",
+    policy_ids: [],
+    enabled: true,
+  });
+
+  const test = await client.testDestination(destination.destination_id);
+  await client.getAlertDeliveries(test.alert_id, { kind: "test" });
 }
 
 await client.shutdown();
@@ -187,16 +214,18 @@ Flushes pending logs and stops the SDK singleton.
 npm test
 ```
 
-## Connector Setup Examples
+## Destination Setup Examples
 
-Create a Slack connector for OpenClaw alerts:
+Create a Slack destination for OpenClaw alerts:
 
 ```ts
 await axios.post(
-  "https://api.chirpier.co/v1.0/webhooks",
+  "https://api.chirpier.co/v1.0/destinations",
   {
     url: "https://hooks.slack.com/services/T000/B000/secret",
-    type: "slack",
+    channel: "slack",
+    scope: "all",
+    policy_ids: [],
     enabled: true,
   },
   {
@@ -205,14 +234,16 @@ await axios.post(
 );
 ```
 
-Create a Telegram connector for OpenClaw alerts:
+Create a Telegram destination for OpenClaw alerts:
 
 ```ts
 await axios.post(
-  "https://api.chirpier.co/v1.0/webhooks",
+  "https://api.chirpier.co/v1.0/destinations",
   {
-    type: "telegram",
+    channel: "telegram",
     enabled: true,
+    scope: "all",
+    policy_ids: [],
     credentials: {
       bot_token: "123456:telegram-bot-token",
       chat_id: "987654321",
@@ -227,5 +258,6 @@ await axios.post(
 Send a test notification:
 
 ```ts
-await client.testWebhook("whk_123");
+const result = await client.testDestination("whk_123");
+await client.getAlertDeliveries(result.alert_id, { kind: "test" });
 ```

package/dist/__tests__/chirpier.test.js

@@ -50,7 +50,10 @@ describe("Chirpier SDK", function () {
     afterEach(function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, index_1.stop)()];
+                case 0:
+                    jest.useRealTimers();
+                    jest.restoreAllMocks();
+                    return [4 /*yield*/, (0, index_1.stop)()];
                 case 1:
                     _a.sent();
                     return [2 /*return*/];
@@ -450,6 +453,306 @@ describe("Chirpier SDK", function () {
                 }
             });
         }); });
+        test("retries network errors", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var client, axiosBackedClient, attempts, flushPromise;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.useFakeTimers();
+                        client = (0, index_1.createClient)({
+                            key: "chp_network_retry_key",
+                            retries: 2,
+                            flushDelay: 10000,
+                        });
+                        axiosBackedClient = client;
+                        attempts = 0;
+                        axiosBackedClient.axiosInstance.defaults.adapter = function (config) { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                attempts += 1;
+                                if (attempts < 3) {
+                                    throw Object.assign(new Error("Network Error"), {
+                                        code: "ECONNRESET",
+                                        config: config,
+                                    });
+                                }
+                                return [2 /*return*/, {
+                                        data: { success: true },
+                                        status: 200,
+                                        statusText: "OK",
+                                        headers: {},
+                                        config: config,
+                                    }];
+                            });
+                        }); };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, client.log({ event: "network.retry", value: 1 })];
+                    case 2:
+                        _a.sent();
+                        flushPromise = client.flush();
+                        return [4 /*yield*/, jest.runAllTimersAsync()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, expect(flushPromise).resolves.toBeUndefined()];
+                    case 4:
+                        _a.sent();
+                        expect(attempts).toBe(3);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, client.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        test("retries 429 responses", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, client, flushPromise;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.useFakeTimers();
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(429, { error: "rate limited" }, { "retry-after": "1" });
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(429, { error: "rate limited" }, { "retry-after": "1" });
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(200, { success: true });
+                        client = (0, index_1.createClient)({
+                            key: "chp_rate_limit_key",
+                            retries: 2,
+                            flushDelay: 10000,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, client.log({ event: "rate.limit", value: 1 })];
+                    case 2:
+                        _a.sent();
+                        flushPromise = client.flush();
+                        return [4 /*yield*/, jest.runAllTimersAsync()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, expect(flushPromise).resolves.toBeUndefined()];
+                    case 4:
+                        _a.sent();
+                        expect(mock.history.post.length).toBe(3);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, client.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        test("does not retry 401 and logs the Chirpier response message", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, errorSpy, client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        errorSpy = jest.spyOn(console, "error").mockImplementation(function () { return undefined; });
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(401, { error: "invalid api key" });
+                        client = (0, index_1.createClient)({
+                            key: "chp_unauthorized_key",
+                            retries: 3,
+                            flushDelay: 10000,
+                            logLevel: 1 /* LogLevel.Error */,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, client.log({ event: "auth.failed", value: 1 })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, client.flush()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, client.flush()];
+                    case 4:
+                        _a.sent();
+                        expect(mock.history.post.length).toBe(1);
+                        expect(errorSpy).toHaveBeenCalledWith("Chirpier API returned 401: invalid api key");
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, client.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        test("does not retry 403 and logs the Chirpier response message", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, errorSpy, client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        errorSpy = jest.spyOn(console, "error").mockImplementation(function () { return undefined; });
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(403, { message: "project is disabled" });
+                        client = (0, index_1.createClient)({
+                            key: "chp_forbidden_key",
+                            retries: 3,
+                            flushDelay: 10000,
+                            logLevel: 1 /* LogLevel.Error */,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, client.log({ event: "auth.forbidden", value: 1 })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, client.flush()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, client.flush()];
+                    case 4:
+                        _a.sent();
+                        expect(mock.history.post.length).toBe(1);
+                        expect(errorSpy).toHaveBeenCalledWith("Chirpier API returned 403: project is disabled");
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, client.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        test.each([404, 500, 503])("does not retry non-retryable status %s", function (status) { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(status, { error: "http ".concat(status) });
+                        client = (0, index_1.createClient)({
+                            key: "chp_non_retryable_".concat(status),
+                            retries: 3,
+                            flushDelay: 10000,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, client.log({ event: "non.retryable.".concat(status), value: 1 })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, client.flush()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, client.flush()];
+                    case 4:
+                        _a.sent();
+                        expect(mock.history.post.length).toBe(1);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, client.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        test("retries 502 responses", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, client, flushPromise;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.useFakeTimers();
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(502, { error: "bad gateway" });
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(502, { error: "bad gateway" });
+                        mock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(200, { success: true });
+                        client = (0, index_1.createClient)({
+                            key: "chp_bad_gateway_key",
+                            retries: 2,
+                            flushDelay: 10000,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, client.log({ event: "bad.gateway", value: 1 })];
+                    case 2:
+                        _a.sent();
+                        flushPromise = client.flush();
+                        return [4 /*yield*/, jest.runAllTimersAsync()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, expect(flushPromise).resolves.toBeUndefined()];
+                    case 4:
+                        _a.sent();
+                        expect(mock.history.post.length).toBe(3);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, client.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        test("flush requeues only retryable failures", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var retryableMock, retryableClient, nonRetryableMock, nonRetryableClient;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        retryableMock = new axios_mock_adapter_1.default(axios_1.default);
+                        retryableMock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(502, { error: "bad gateway" });
+                        retryableMock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(200, { success: true });
+                        retryableClient = (0, index_1.createClient)({
+                            key: "chp_retryable_requeue_key",
+                            retries: 0,
+                            flushDelay: 10000,
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 7]);
+                        return [4 /*yield*/, retryableClient.log({ event: "retryable.requeue", value: 1 })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, retryableClient.flush()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, retryableClient.flush()];
+                    case 4:
+                        _a.sent();
+                        expect(retryableMock.history.post.length).toBe(2);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, retryableClient.shutdown()];
+                    case 6:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 7:
+                        nonRetryableMock = new axios_mock_adapter_1.default(axios_1.default);
+                        nonRetryableMock.onPost(constants_1.DEFAULT_API_ENDPOINT).replyOnce(404, { error: "not found" });
+                        nonRetryableClient = (0, index_1.createClient)({
+                            key: "chp_non_retryable_requeue_key",
+                            retries: 0,
+                            flushDelay: 10000,
+                            logLevel: 0 /* LogLevel.None */,
+                        });
+                        _a.label = 8;
+                    case 8:
+                        _a.trys.push([8, , 12, 14]);
+                        return [4 /*yield*/, nonRetryableClient.log({ event: "non.retryable.drop", value: 1 })];
+                    case 9:
+                        _a.sent();
+                        return [4 /*yield*/, nonRetryableClient.flush()];
+                    case 10:
+                        _a.sent();
+                        return [4 /*yield*/, nonRetryableClient.flush()];
+                    case 11:
+                        _a.sent();
+                        expect(nonRetryableMock.history.post.length).toBe(1);
+                        return [3 /*break*/, 14];
+                    case 12: return [4 /*yield*/, nonRetryableClient.shutdown()];
+                    case 13:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        }); });
         test("getEventLogs uses servicer endpoint with period, limit, and offset", function () { return __awaiter(void 0, void 0, void 0, function () {
             var mock, client;
             return __generator(this, function (_a) {
@@ -474,6 +777,66 @@ describe("Chirpier SDK", function () {
                 }
             });
         }); });
+        test("event, policy, alert, and destination helpers use servicer endpoints", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, client, createdEvent, policy, alert_1, destination, updatedDestination;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        mock.onPost("https://api.chirpier.co/v1.0/events").reply(200, { event_id: "evt_123", event: "tool.errors.count", public: false, timezone: "UTC" });
+                        mock.onGet("https://api.chirpier.co/v1.0/events/evt_123").reply(200, { event_id: "evt_123", event: "tool.errors.count", public: false, timezone: "UTC" });
+                        mock.onGet("https://api.chirpier.co/v1.0/policies/pol_123").reply(200, { policy_id: "pol_123", event_id: "evt_123", title: "Policy", channel: "ops", period: "hour", aggregate: "sum", condition: "gt", threshold: 1, severity: "warning", enabled: true });
+                        mock.onPut("https://api.chirpier.co/v1.0/policies/pol_123").reply(200, { policy_id: "pol_123", event_id: "evt_123", title: "Updated", channel: "ops", period: "hour", aggregate: "sum", condition: "gt", threshold: 1, severity: "warning", enabled: true });
+                        mock.onGet("https://api.chirpier.co/v1.0/alerts/alrt_123").reply(200, { alert_id: "alrt_123", policy_id: "pol_123", event_id: "evt_123", event: "tool.errors.count", title: "Alert", channel: "ops", period: "hour", aggregate: "sum", condition: "gt", threshold: 1, severity: "warning", status: "triggered", value: 2, count: 2, min: 1, max: 1 });
+                        mock.onGet("https://api.chirpier.co/v1.0/destinations").reply(200, []);
+                        mock.onPost("https://api.chirpier.co/v1.0/destinations").reply(200, { destination_id: "dst_123", channel: "slack", scope: "all", enabled: true });
+                        mock.onGet("https://api.chirpier.co/v1.0/destinations/dst_123").reply(200, { destination_id: "dst_123", channel: "slack", scope: "all", enabled: true });
+                        mock.onPut("https://api.chirpier.co/v1.0/destinations/dst_123").reply(200, { destination_id: "dst_123", channel: "slack", scope: "all", enabled: false });
+                        client = (0, index_1.createClient)({ key: "chp_client_route_key" });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 11, 13]);
+                        return [4 /*yield*/, client.createEvent({ event: "tool.errors.count" })];
+                    case 2:
+                        createdEvent = _a.sent();
+                        expect(createdEvent.event_id).toBe("evt_123");
+                        return [4 /*yield*/, client.getEvent("evt_123")];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, client.getPolicy("pol_123")];
+                    case 4:
+                        policy = _a.sent();
+                        expect(policy.policy_id).toBe("pol_123");
+                        return [4 /*yield*/, client.updatePolicy("pol_123", { title: "Updated" })];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, client.getAlert("alrt_123")];
+                    case 6:
+                        alert_1 = _a.sent();
+                        expect(alert_1.alert_id).toBe("alrt_123");
+                        return [4 /*yield*/, client.listDestinations()];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, client.createDestination({ channel: "slack", scope: "all", enabled: true })];
+                    case 8:
+                        destination = _a.sent();
+                        expect(destination.destination_id).toBe("dst_123");
+                        return [4 /*yield*/, client.getDestination("dst_123")];
+                    case 9:
+                        _a.sent();
+                        return [4 /*yield*/, client.updateDestination("dst_123", { enabled: false })];
+                    case 10:
+                        updatedDestination = _a.sent();
+                        expect(updatedDestination.enabled).toBe(false);
+                        return [3 /*break*/, 13];
+                    case 11: return [4 /*yield*/, client.shutdown()];
+                    case 12:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 13: return [2 /*return*/];
+                }
+            });
+        }); });
         test("getAlertDeliveries uses pagination params", function () { return __awaiter(void 0, void 0, void 0, function () {
             var mock, client;
             return __generator(this, function (_a) {
@@ -522,21 +885,61 @@ describe("Chirpier SDK", function () {
                 }
             });
         }); });
-        test("testWebhook posts to servicer endpoint", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var mock, client;
+        test("testDestination posts to servicer endpoint", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, client, result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         mock = new axios_mock_adapter_1.default(axios_1.default);
-                        mock.onPost("https://api.chirpier.co/v1.0/webhooks/whk_123/test").reply(200);
-                        client = (0, index_1.createClient)({ key: "chp_client_webhook_key" });
+                        mock.onPost("https://api.chirpier.co/v1.0/destinations/whk_123/test").reply(200, {
+                            alert_id: "alrt_123",
+                            destination_id: "whk_123",
+                            status: "sent",
+                        });
+                        client = (0, index_1.createClient)({ key: "chp_client_destination_key" });
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, , 3, 5]);
-                        return [4 /*yield*/, client.testWebhook("whk_123")];
+                        return [4 /*yield*/, client.testDestination("whk_123")];
                     case 2:
+                        result = _a.sent();
+                        expect(result.alert_id).toBe("alrt_123");
+                        expect(mock.history.post[0].url).toBe("https://api.chirpier.co/v1.0/destinations/whk_123/test");
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, client.shutdown()];
+                    case 4:
                         _a.sent();
-                        expect(mock.history.post[0].url).toBe("https://api.chirpier.co/v1.0/webhooks/whk_123/test");
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); });
+        test("getEventAnalytics uses analytics endpoint", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var mock, client, analytics;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mock = new axios_mock_adapter_1.default(axios_1.default);
+                        mock.onGet("https://api.chirpier.co/v1.0/events/evt_123/analytics?view=window&period=1h&previous=previous_window").reply(200, {
+                            event_id: "evt_123",
+                            view: "window",
+                            period: "1h",
+                            previous: "previous_window",
+                            data: null,
+                        });
+                        client = (0, index_1.createClient)({ key: "chp_client_analytics_key" });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 5]);
+                        return [4 /*yield*/, client.getEventAnalytics("evt_123", {
+                                view: "window",
+                                period: "1h",
+                                previous: "previous_window",
+                            })];
+                    case 2:
+                        analytics = _a.sent();
+                        expect(analytics.event_id).toBe("evt_123");
+                        expect(mock.history.get[0].url).toBe("https://api.chirpier.co/v1.0/events/evt_123/analytics?view=window&period=1h&previous=previous_window");
                         return [3 /*break*/, 5];
                     case 3: return [4 /*yield*/, client.shutdown()];
                     case 4: