doover-js 0.11.0 → 0.13.0

package/dist/test/apis.test.js

@@ -1,408 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const mocha_1 = require("mocha");
-const agents_api_1 = require("../apis/agents-api");
-const aggregates_api_1 = require("../apis/aggregates-api");
-const alarms_api_1 = require("../apis/alarms-api");
-const channels_api_1 = require("../apis/channels-api");
-const connections_api_1 = require("../apis/connections-api");
-const messages_api_1 = require("../apis/messages-api");
-const notifications_api_1 = require("../apis/notifications-api");
-const permissions_api_1 = require("../apis/permissions-api");
-const processors_api_1 = require("../apis/processors-api");
-const turn_api_1 = require("../apis/turn-api");
-const rest_client_1 = require("../http/rest-client");
-const snowflake_1 = require("../utils/snowflake");
-const helpers_1 = require("./helpers");
-function setupRest(responseFactory) {
-    const fetchMock = (0, helpers_1.createFetchMock)(responseFactory);
-    const rest = new rest_client_1.RestClient({
-        dataRestUrl: "https://api.example.com",
-        controlApiUrl: "https://control.example.com",
-        dataWssUrl: "wss://ws.example.com",
-        fetchImpl: fetchMock,
-    });
-    return { rest, fetchMock };
-}
-(0, mocha_1.describe)("API clients", () => {
-    (0, mocha_1.it)("covers agents batch methods", async () => {
-        const id = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00Z"));
-        const { rest, fetchMock } = setupRest((url) => {
-            if (url.includes("/messages")) {
-                return (0, helpers_1.createJsonResponse)({
-                    results: [
-                        {
-                            id,
-                            author_id: "u",
-                            channel: { agent_id: "a1", name: "c1" },
-                            data: {},
-                            attachments: [],
-                        },
-                    ],
-                    count: 1,
-                });
-            }
-            return (0, helpers_1.createJsonResponse)({
-                results: [{ agent_id: "a1", data: {}, attachments: [] }],
-                count: 1,
-            });
-        });
-        const api = new agents_api_1.AgentsApi(rest);
-        const messages = await api.getMultiAgentMessages("c1", {
-            agent_id: ["a1", "a2"],
-            limit: 5,
-        });
-        const aggregates = await api.getMultiAgentAggregates("c1", {
-            agent_id: ["a1"],
-        });
-        (0, chai_1.expect)(messages.results[0].timestamp).to.be.greaterThan(0);
-        (0, chai_1.expect)(aggregates.results).to.have.length(1);
-        (0, chai_1.expect)(fetchMock.getCall(0).args[0]).to.equal("https://api.example.com/agents/channels/c1/messages?agent_id=a1&agent_id=a2&limit=5");
-        (0, chai_1.expect)(fetchMock.getCall(1).args[0]).to.equal("https://api.example.com/agents/channels/c1/aggregates?agent_id=a1");
-    });
-    (0, mocha_1.it)("chunks getMultiAgentAggregates over the per-request agent cap", async () => {
-        const { rest, fetchMock } = setupRest((url) => {
-            const ids = [...new URL(url).searchParams.getAll("agent_id")];
-            return (0, helpers_1.createJsonResponse)({
-                results: ids.map((id) => ({ agent_id: id, data: {}, attachments: [] })),
-                count: ids.length,
-            });
-        });
-        const api = new agents_api_1.AgentsApi(rest);
-        // 600 agents → 3 chunks of 250/250/100.
-        const agentIds = Array.from({ length: 600 }, (_, i) => `a${i}`);
-        const aggregates = await api.getMultiAgentAggregates("c1", {
-            agent_id: agentIds,
-        });
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(3);
-        (0, chai_1.expect)(aggregates.results).to.have.length(600);
-        (0, chai_1.expect)(aggregates.count).to.equal(600);
-        // Every agent is represented exactly once across the merged chunks.
-        const returnedIds = aggregates.results.map((r) => r.agent_id).sort();
-        (0, chai_1.expect)(returnedIds).to.deep.equal([...agentIds].sort());
-    });
-    (0, mocha_1.it)("chunks getMultiAgentMessages over the per-request agent cap", async () => {
-        const baseTs = new Date("2026-01-01T00:00:00Z");
-        const { rest, fetchMock } = setupRest((url) => {
-            const ids = [...new URL(url).searchParams.getAll("agent_id")];
-            return (0, helpers_1.createJsonResponse)({
-                results: ids.map((id, i) => ({
-                    id: (0, snowflake_1.generateSnowflakeIdAtTime)(new Date(baseTs.getTime() + i)),
-                    author_id: "u",
-                    channel: { agent_id: id, name: "c1" },
-                    data: {},
-                    attachments: [],
-                })),
-                count: ids.length,
-            });
-        });
-        const api = new agents_api_1.AgentsApi(rest);
-        // 600 agents → 3 chunks of 250/250/100.
-        const agentIds = Array.from({ length: 600 }, (_, i) => `a${i}`);
-        const messages = await api.getMultiAgentMessages("c1", {
-            agent_id: agentIds,
-            agent_message_limit: 50,
-        });
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(3);
-        (0, chai_1.expect)(messages.results).to.have.length(600);
-        (0, chai_1.expect)(messages.count).to.equal(600);
-        const returnedIds = messages.results
-            .map((m) => m.channel.agent_id)
-            .sort();
-        (0, chai_1.expect)(returnedIds).to.deep.equal([...agentIds].sort());
-        // Per-request param survives chunking.
-        for (let i = 0; i < 3; i++) {
-            const url = fetchMock.getCall(i).args[0];
-            (0, chai_1.expect)(url).to.include("agent_message_limit=50");
-        }
-    });
-    (0, mocha_1.it)("merges next_cursors and at_limit_agent_ids across chunks", async () => {
-        let call = 0;
-        const cursors = [
-            { "a0": "100", "a1": "200" },
-            { "a250": "150" },
-        ];
-        const atLimit = [["a0", "a1"], ["a250"]];
-        const { rest } = setupRest((url) => {
-            const idx = call++;
-            const ids = [...new URL(url).searchParams.getAll("agent_id")];
-            return (0, helpers_1.createJsonResponse)({
-                results: ids.map((id) => ({
-                    id: (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00Z")),
-                    author_id: "u",
-                    channel: { agent_id: id, name: "c1" },
-                    data: {},
-                    attachments: [],
-                })),
-                count: ids.length,
-                next: idx === 0 ? "200" : "150",
-                next_cursors: cursors[idx],
-                at_limit_agent_ids: atLimit[idx],
-            });
-        });
-        const api = new agents_api_1.AgentsApi(rest);
-        const agentIds = Array.from({ length: 300 }, (_, i) => `a${i}`);
-        const messages = await api.getMultiAgentMessages("c1", {
-            agent_id: agentIds,
-        });
-        (0, chai_1.expect)(messages.next).to.equal("200"); // max across chunks
-        (0, chai_1.expect)(messages.next_cursors).to.deep.equal({
-            a0: "100",
-            a1: "200",
-            a250: "150",
-        });
-        (0, chai_1.expect)(messages.at_limit_agent_ids?.sort()).to.deep.equal([
-            "a0",
-            "a1",
-            "a250",
-        ]);
-    });
-    (0, mocha_1.it)("covers channels methods", async () => {
-        const { rest, fetchMock } = setupRest(() => (0, helpers_1.createJsonResponse)([]));
-        const api = new channels_api_1.ChannelsApi(rest);
-        await api.listChannels("a1", { include_archived: true });
-        await api.getChannel("a1", "c1", { include_aggregate: true });
-        await api.createChannel("a1", "c1", { is_private: true });
-        await api.putChannel("a1", "c1", { is_private: false });
-        await api.listDataSeries("a1", { field_name: ["temp"] });
-        (0, chai_1.expect)(fetchMock.getCalls().map((call) => [call.args[0], call.args[1]?.method ?? "GET"])).to.deep.equal([
-            ["https://api.example.com/agents/a1/channels?include_archived=true", "GET"],
-            ["https://api.example.com/agents/a1/channels/c1?include_aggregate=true", "GET"],
-            ["https://api.example.com/agents/a1/channels/c1", "POST"],
-            ["https://api.example.com/agents/a1/channels/c1", "PUT"],
-            ["https://api.example.com/agents/a1/data_series?field_name=temp", "GET"],
-        ]);
-    });
-    (0, mocha_1.it)("covers messages methods and multipart helper", async () => {
-        const id = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00Z"));
-        const { rest, fetchMock } = setupRest((url) => {
-            if (url.includes("/attachments/")) {
-                return (0, helpers_1.createBlobResponse)("data");
-            }
-            if (url.includes("/timeseries")) {
-                return (0, helpers_1.createJsonResponse)({ count: 1, results: [{ value: 1, message_id: id }] });
-            }
-            if (url.endsWith(`/messages/${id}`)) {
-                return (0, helpers_1.createJsonResponse)({
-                    id,
-                    author_id: "u",
-                    channel: { agent_id: "a1", name: "c1" },
-                    data: {},
-                    attachments: [],
-                });
-            }
-            if (url.endsWith("/messages")) {
-                return (0, helpers_1.createJsonResponse)({
-                    id,
-                    author_id: "u",
-                    channel: { agent_id: "a1", name: "c1" },
-                    data: {},
-                    attachments: [],
-                });
-            }
-            return (0, helpers_1.createJsonResponse)([
-                {
-                    id,
-                    author_id: "u",
-                    channel: { agent_id: "a1", name: "c1" },
-                    data: {},
-                    attachments: [],
-                },
-            ]);
-        });
-        const api = new messages_api_1.MessagesApi(rest);
-        const list = await api.listMessages("a1", "c1", { limit: 2 });
-        const posted = await api.postMessage("a1", "c1", { data: { x: 1 } });
-        const series = await api.getTimeseries("a1", "c1", { field_name: ["x"] });
-        const message = await api.getMessage("a1", "c1", id);
-        await api.putMessage("a1", "c1", id, { data: { x: 2 } }, { suppress_response: true });
-        await api.patchMessage("a1", "c1", id, { data: { x: 3 } }, { clear_attachments: true });
-        await api.deleteMessage("a1", "c1", id);
-        const blob = await api.getMessageAttachment("a1", "c1", id, "att-1");
-        const formData = api.createMultipartPayload({ data: { x: 1 } }, [new Blob(["a"])]);
-        (0, chai_1.expect)(list[0].timestamp).to.be.greaterThan(0);
-        (0, chai_1.expect)(posted.timestamp).to.be.greaterThan(0);
-        (0, chai_1.expect)(series.count).to.equal(1);
-        (0, chai_1.expect)(message.id).to.equal(id);
-        (0, chai_1.expect)(await blob.text()).to.equal("data");
-        (0, chai_1.expect)(formData.get("json_payload")).to.equal(JSON.stringify({ data: { x: 1 } }));
-        (0, chai_1.expect)(formData.get("attachment-0")).to.be.instanceOf(Blob);
-    });
-    (0, mocha_1.it)("pages forward with a bare `after`: sends no `before`, keeps oldest-first", async () => {
-        const older = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00Z"));
-        const newer = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-02T00:00:00Z"));
-        // The `after`-only route returns oldest-first natively (scan_index_forward).
-        const nativeAsc = [
-            { id: older, author_id: "u", channel: { agent_id: "a1", name: "c1" }, data: {}, attachments: [] },
-            { id: newer, author_id: "u", channel: { agent_id: "a1", name: "c1" }, data: {}, attachments: [] },
-        ];
-        let lastQuery;
-        const { rest } = setupRest((url) => {
-            if (url.endsWith("/messages") || url.includes("/messages?")) {
-                lastQuery = new URL(url).searchParams;
-                return (0, helpers_1.createJsonResponse)(nativeAsc);
-            }
-            return (0, helpers_1.createJsonResponse)([]);
-        });
-        const api = new messages_api_1.MessagesApi(rest);
-        // asc: server order already matches → no reversal, no `before` sent.
-        const asc = await api.listMessages("a1", "c1", { after: older, limit: 5, order: "asc" });
-        (0, chai_1.expect)(lastQuery?.get("after")).to.equal(older);
-        (0, chai_1.expect)(lastQuery?.has("before"), "bare `after` must not send `before`").to.equal(false);
-        (0, chai_1.expect)(asc.map((m) => m.id)).to.deep.equal([older, newer]);
-        // desc over the same forward route reverses the native ascending page.
-        const desc = await api.listMessages("a1", "c1", { after: older, limit: 5, order: "desc" });
-        (0, chai_1.expect)(desc.map((m) => m.id)).to.deep.equal([newer, older]);
-        // With `before` present, `after` is only a floor and both bounds are sent.
-        await api.listMessages("a1", "c1", { before: newer, after: older, limit: 5, order: "asc" });
-        (0, chai_1.expect)(lastQuery?.get("before")).to.equal(newer);
-        (0, chai_1.expect)(lastQuery?.get("after")).to.equal(older);
-    });
-    (0, mocha_1.it)("covers aggregates and alarms methods", async () => {
-        const { rest, fetchMock } = setupRest((url) => {
-            if (url.includes("/attachments/")) {
-                return (0, helpers_1.createBlobResponse)("agg");
-            }
-            if (url.includes("/alarms")) {
-                return (0, helpers_1.createJsonResponse)({
-                    id: "alarm",
-                    name: "a",
-                    description: "",
-                    enabled: true,
-                    key: "x",
-                    operator: "gt",
-                    value: 1,
-                    state: "OK",
-                    expiry_mins: null,
-                    entered_state_ts: 1,
-                });
-            }
-            return (0, helpers_1.createJsonResponse)({ data: {}, attachments: [] });
-        });
-        const aggregates = new aggregates_api_1.AggregatesApi(rest);
-        const alarms = new alarms_api_1.AlarmsApi(rest);
-        await aggregates.getAggregate("a1", "c1");
-        await aggregates.putAggregate("a1", "c1", { data: 1 }, { log_update: true });
-        await aggregates.patchAggregate("a1", "c1", { data: 2 }, { clear_attachments: true });
-        const aggregateBlob = await aggregates.getAggregateAttachment("a1", "c1", "att-1");
-        await alarms.listAlarms("a1", "c1");
-        await alarms.createAlarm("a1", "c1", { name: "a", key: "x", operator: "gt", value: 1 });
-        await alarms.getAlarm("a1", "c1", "alarm");
-        await alarms.putAlarm("a1", "c1", "alarm", { name: "a", key: "x", operator: "gt", value: 1 });
-        // A rate alarm states its condition with rate_threshold/rate_window_ms and
-        // must leave `value` unset.
-        await alarms.createAlarm("a1", "c1", {
-            name: "rising",
-            key: "level",
-            operator: "gt",
-            rate_threshold: 0.05,
-            rate_window_ms: 600000,
-            topic_name: "level-rising",
-            notification_policy: "opt-in",
-            messages: { alarm: { notify: true, text: "Level rising fast" } },
-        });
-        await alarms.patchAlarm("a1", "c1", "alarm", { enabled: false });
-        await alarms.patchAlarm("a1", "c1", "alarm", { messages: { ok: { notify: false } } });
-        await alarms.deleteAlarm("a1", "c1", "alarm");
-        (0, chai_1.expect)(await aggregateBlob.text()).to.equal("agg");
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(12);
-    });
-    (0, mocha_1.it)("covers connections and notifications methods", async () => {
-        const { rest, fetchMock } = setupRest(() => (0, helpers_1.createJsonResponse)({ subscriptions: [], endpoints: [], subscribers: [] }));
-        const connections = new connections_api_1.ConnectionsApi(rest);
-        const notifications = new notifications_api_1.NotificationsApi(rest);
-        await connections.getAgentConnections("a1");
-        await connections.getAgentConnectionHistory("a1", { default_connection: true });
-        await connections.getAgentSubscriptionHistory("a1", { channel: "{\"agent_id\":\"a1\",\"name\":\"c1\"}" });
-        await connections.getConnection("conn");
-        await connections.getChannelSubscriptions("a1", "c1");
-        await connections.syncConnection("a1");
-        const syncCall = fetchMock
-            .getCalls()
-            .find((call) => call.args[0].endsWith("/agents/a1/connection_sync"));
-        (0, chai_1.expect)(syncCall).to.not.equal(undefined);
-        (0, chai_1.expect)(syncCall.args[1].method).to.equal("POST");
-        await notifications.getAgentNotifications("a1");
-        await notifications.getAgentNotificationEndpoints("a1", "browser");
-        await notifications.getAgentNotificationEndpointSummaries("a1");
-        await notifications.createNotificationEndpoint("a1", {
-            name: "browser",
-            type: 3,
-            extra_data: {},
-            default: true,
-        });
-        await notifications.updateNotificationEndpoint("a1", "e1", { name: "browser-2" });
-        await notifications.deleteNotificationEndpoint("a1", "e1");
-        await notifications.testNotificationEndpoint("a1", "e1");
-        await notifications.getAgentNotificationSubscriptions("a1", "a2");
-        await notifications.createNotificationSubscription("a1", {
-            subscribe_to: "a2",
-            severity: 3,
-            topic_filter: ["*"],
-        });
-        await notifications.getAgentDefaultNotificationSubscriptions("a1", "a2");
-        await notifications.updateDefaultNotificationSubscription("a1", "a2", {
-            severity: 5,
-            topic_filter: ["^dev/alarms/default/[^/]+/triggered$"],
-            topic_filter_mode: "regex",
-        });
-        await notifications.deleteDefaultNotificationSubscription("a1", "a2");
-        await notifications.updateNotificationSubscription("a1", "s1", { severity: 4 });
-        await notifications.deleteNotificationSubscription("a1", "s1");
-        await notifications.getAgentNotificationSubscribers("a1");
-        await notifications.updateMeWebPushEndpoint({
-            old_endpoint: "old",
-            endpoint: "new",
-            key_p256dh: "p",
-            key_auth: "a",
-            expires_at: 1,
-        });
-        await notifications.getWebPushPublicKey();
-        const summaryCall = fetchMock
-            .getCalls()
-            .find((call) => call.args[0].endsWith("/agents/a1/notifications/endpoints/summary"));
-        (0, chai_1.expect)(summaryCall).to.not.equal(undefined);
-        const defaultPatch = fetchMock
-            .getCalls()
-            .find((call) => call.args[0].endsWith("/agents/a1/notifications/subscriptions/default/a2") && call.args[1].method === "PATCH");
-        (0, chai_1.expect)(defaultPatch).to.not.equal(undefined);
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(23);
-    });
-    (0, mocha_1.it)("covers permissions, processors, and turn methods", async () => {
-        const { rest, fetchMock } = setupRest(() => (0, helpers_1.createJsonResponse)({ db: { agent_id: "a1", is_superuser: false, resources: [] } }));
-        const permissions = new permissions_api_1.PermissionsApi(rest);
-        const processors = new processors_api_1.ProcessorsApi(rest);
-        const turn = new turn_api_1.TurnApi(rest);
-        await permissions.getAgentPermission("a1");
-        await permissions.getAgentPermissionDebug("a1");
-        await permissions.syncPermissions({ agent_permissions: [] });
-        await processors.createProcessorSchedule("a1", "sched", {
-            app_key: "app",
-            permissions: [],
-        });
-        await processors.deleteProcessorSchedule("a1", "sched");
-        await processors.regenerateScheduleToken("a1", "sched");
-        await processors.getScheduleInfo("sched");
-        await processors.getScheduleInfoAlias("sched");
-        await processors.createProcessorSubscription("a1", "sub", {
-            subscription_arn: "arn",
-            app_key: "app",
-            permissions: [],
-        });
-        await processors.deleteProcessorSubscription("a1", "sub");
-        await processors.getProcessorSubscriptionInfo("arn");
-        await processors.getProcessorSubscriptionInfoAlias("arn");
-        await processors.createIngestionEndpoint("a1", "ing", {
-            lambda_arn: "arn",
-            cidr_ranges: [],
-            throttle_limit: 1,
-            app_key: "app",
-            permissions: [],
-        });
-        await processors.deleteIngestionEndpoint("a1", "ing");
-        await processors.invokeIngestionEndpoint("a1", "ing", { hello: "world" }, { wait: true });
-        await turn.createTurnToken({ role: "client", camera_name: "cam", device_id: "a1" });
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(16);
-    });
-});