doover-js 0.1.0

package/dist/http/rest-client.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestClient = void 0;
+const errors_1 = require("./errors");
+class RestClient {
+    constructor(config) {
+        this.config = {
+            ...config,
+            sharing: config.sharing ?? "internal",
+            organisationId: config.organisationId ?? null,
+            impersonateUserStorageKey: config.impersonateUserStorageKey ?? "impersonate_user_id",
+        };
+    }
+    async request(options) {
+        const method = options.method ?? "GET";
+        const url = this.buildUrl(options.baseUrl ?? this.config.dataRestUrl, options.path, options.query);
+        const headers = new Headers(options.headers);
+        const body = this.normalizeBody(options.body, headers);
+        headers.set("X-Doover-Sharing", this.config.sharing);
+        if (this.config.organisationId) {
+            headers.set("X-Doover-Organisation", this.config.organisationId);
+        }
+        const impersonated = this.getImpersonatedUserId();
+        if (impersonated) {
+            headers.set("X-Doover-Assume", impersonated);
+        }
+        const fetchImpl = this.config.fetchImpl ?? fetch;
+        const response = await fetchImpl(url, {
+            method,
+            headers,
+            body,
+            credentials: "include",
+        });
+        const payload = await this.parseResponse(response);
+        if (!response.ok) {
+            throw new errors_1.DooverApiError({
+                status: response.status,
+                body: payload,
+                url,
+                method,
+                message: typeof payload === "object" &&
+                    payload !== null &&
+                    "message" in payload &&
+                    typeof payload.message === "string"
+                    ? payload.message
+                    : undefined,
+            });
+        }
+        return payload;
+    }
+    get(path, query, baseUrl) {
+        return this.request({ path, query, baseUrl });
+    }
+    post(path, body, query, baseUrl) {
+        return this.request({ path, body, query, method: "POST", baseUrl });
+    }
+    put(path, body, query, baseUrl) {
+        return this.request({ path, body, query, method: "PUT", baseUrl });
+    }
+    patch(path, body, query, baseUrl) {
+        return this.request({ path, body, query, method: "PATCH", baseUrl });
+    }
+    delete(path, query, baseUrl) {
+        return this.request({ path, query, method: "DELETE", baseUrl });
+    }
+    buildUrl(baseUrl, path, query) {
+        const normalizedBase = baseUrl.replace(/\/+$/, "");
+        const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+        const finalUrl = new URL(`${normalizedBase}${normalizedPath}`);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    value.forEach((item) => finalUrl.searchParams.append(key, String(item)));
+                }
+                else {
+                    finalUrl.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return finalUrl.toString();
+    }
+    normalizeBody(body, headers) {
+        if (body === undefined || body === null) {
+            return undefined;
+        }
+        if (typeof FormData !== "undefined" &&
+            body instanceof FormData) {
+            return body;
+        }
+        if (typeof body === "string" || body instanceof Blob || ArrayBuffer.isView(body)) {
+            return body;
+        }
+        headers.set("Content-Type", "application/json");
+        return JSON.stringify(body);
+    }
+    async parseResponse(response) {
+        if (response.status === 204) {
+            return undefined;
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            return response.json();
+        }
+        if (contentType.includes("application/octet-stream") ||
+            contentType.includes("application/pdf")) {
+            return response.blob();
+        }
+        const text = await response.text();
+        if (!text) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    getImpersonatedUserId() {
+        if (typeof sessionStorage === "undefined") {
+            return null;
+        }
+        return sessionStorage.getItem(this.config.impersonateUserStorageKey);
+    }
+}
+exports.RestClient = RestClient;

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { DooverClient } from "./client/doover-client";
+export { AgentsApi } from "./apis/agents-api";
+export { AggregatesApi } from "./apis/aggregates-api";
+export { AlarmsApi } from "./apis/alarms-api";
+export { ChannelsApi } from "./apis/channels-api";
+export { ConnectionsApi } from "./apis/connections-api";
+export { MessagesApi } from "./apis/messages-api";
+export { NotificationsApi } from "./apis/notifications-api";
+export { PermissionsApi } from "./apis/permissions-api";
+export { ProcessorsApi } from "./apis/processors-api";
+export { TurnApi } from "./apis/turn-api";
+export { GatewayClient } from "./gateway/gateway-client";
+export type * from "./gateway/types";
+export { RestClient } from "./http/rest-client";
+export type { DooverClientConfig } from "./http/rest-client";
+export { DooverApiError, DooverGatewayError, DooverValidationError, } from "./http/errors";
+export { DooverDataProvider } from "./viewer/doover-data-provider";
+export { getIdentifierFromPath } from "./viewer/path-parsing";
+export type * from "./types/common";
+export type * from "./types/openapi";
+export type * from "./types/viewer";
+export { addTimestampToMessage, extractSnowflakeId, generateSnowflakeIdAtTime, } from "./utils/snowflake";

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSnowflakeIdAtTime = exports.extractSnowflakeId = exports.addTimestampToMessage = exports.getIdentifierFromPath = exports.DooverDataProvider = exports.DooverValidationError = exports.DooverGatewayError = exports.DooverApiError = exports.RestClient = exports.GatewayClient = exports.TurnApi = exports.ProcessorsApi = exports.PermissionsApi = exports.NotificationsApi = exports.MessagesApi = exports.ConnectionsApi = exports.ChannelsApi = exports.AlarmsApi = exports.AggregatesApi = exports.AgentsApi = exports.DooverClient = void 0;
+var doover_client_1 = require("./client/doover-client");
+Object.defineProperty(exports, "DooverClient", { enumerable: true, get: function () { return doover_client_1.DooverClient; } });
+var agents_api_1 = require("./apis/agents-api");
+Object.defineProperty(exports, "AgentsApi", { enumerable: true, get: function () { return agents_api_1.AgentsApi; } });
+var aggregates_api_1 = require("./apis/aggregates-api");
+Object.defineProperty(exports, "AggregatesApi", { enumerable: true, get: function () { return aggregates_api_1.AggregatesApi; } });
+var alarms_api_1 = require("./apis/alarms-api");
+Object.defineProperty(exports, "AlarmsApi", { enumerable: true, get: function () { return alarms_api_1.AlarmsApi; } });
+var channels_api_1 = require("./apis/channels-api");
+Object.defineProperty(exports, "ChannelsApi", { enumerable: true, get: function () { return channels_api_1.ChannelsApi; } });
+var connections_api_1 = require("./apis/connections-api");
+Object.defineProperty(exports, "ConnectionsApi", { enumerable: true, get: function () { return connections_api_1.ConnectionsApi; } });
+var messages_api_1 = require("./apis/messages-api");
+Object.defineProperty(exports, "MessagesApi", { enumerable: true, get: function () { return messages_api_1.MessagesApi; } });
+var notifications_api_1 = require("./apis/notifications-api");
+Object.defineProperty(exports, "NotificationsApi", { enumerable: true, get: function () { return notifications_api_1.NotificationsApi; } });
+var permissions_api_1 = require("./apis/permissions-api");
+Object.defineProperty(exports, "PermissionsApi", { enumerable: true, get: function () { return permissions_api_1.PermissionsApi; } });
+var processors_api_1 = require("./apis/processors-api");
+Object.defineProperty(exports, "ProcessorsApi", { enumerable: true, get: function () { return processors_api_1.ProcessorsApi; } });
+var turn_api_1 = require("./apis/turn-api");
+Object.defineProperty(exports, "TurnApi", { enumerable: true, get: function () { return turn_api_1.TurnApi; } });
+var gateway_client_1 = require("./gateway/gateway-client");
+Object.defineProperty(exports, "GatewayClient", { enumerable: true, get: function () { return gateway_client_1.GatewayClient; } });
+var rest_client_1 = require("./http/rest-client");
+Object.defineProperty(exports, "RestClient", { enumerable: true, get: function () { return rest_client_1.RestClient; } });
+var errors_1 = require("./http/errors");
+Object.defineProperty(exports, "DooverApiError", { enumerable: true, get: function () { return errors_1.DooverApiError; } });
+Object.defineProperty(exports, "DooverGatewayError", { enumerable: true, get: function () { return errors_1.DooverGatewayError; } });
+Object.defineProperty(exports, "DooverValidationError", { enumerable: true, get: function () { return errors_1.DooverValidationError; } });
+var doover_data_provider_1 = require("./viewer/doover-data-provider");
+Object.defineProperty(exports, "DooverDataProvider", { enumerable: true, get: function () { return doover_data_provider_1.DooverDataProvider; } });
+var path_parsing_1 = require("./viewer/path-parsing");
+Object.defineProperty(exports, "getIdentifierFromPath", { enumerable: true, get: function () { return path_parsing_1.getIdentifierFromPath; } });
+var snowflake_1 = require("./utils/snowflake");
+Object.defineProperty(exports, "addTimestampToMessage", { enumerable: true, get: function () { return snowflake_1.addTimestampToMessage; } });
+Object.defineProperty(exports, "extractSnowflakeId", { enumerable: true, get: function () { return snowflake_1.extractSnowflakeId; } });
+Object.defineProperty(exports, "generateSnowflakeIdAtTime", { enumerable: true, get: function () { return snowflake_1.generateSnowflakeIdAtTime; } });

package/dist/test/apis.test.d.ts

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

package/dist/test/apis.test.js

@@ -0,0 +1,248 @@
+"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)("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)("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 });
+        await alarms.patchAlarm("a1", "c1", "alarm", { enabled: 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(10);
+    });
+    (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 notifications.getAgentNotifications("a1");
+        await notifications.getAgentNotificationEndpoints("a1", "browser");
+        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.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();
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(20);
+    });
+    (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);
+    });
+});

package/dist/test/doover-client.test.d.ts

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

package/dist/test/doover-client.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const doover_client_1 = require("../client/doover-client");
+const helpers_1 = require("./helpers");
+(0, mocha_1.describe)("DooverClient", () => {
+    (0, mocha_1.it)("wires all public subclients", () => {
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: (0, helpers_1.createFetchMock)(),
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        (0, chai_1.expect)(client.viewer).to.exist;
+        (0, chai_1.expect)(client.channels).to.exist;
+        (0, chai_1.expect)(client.messages).to.exist;
+        (0, chai_1.expect)(client.aggregates).to.exist;
+        (0, chai_1.expect)(client.alarms).to.exist;
+        (0, chai_1.expect)(client.connections).to.exist;
+        (0, chai_1.expect)(client.notifications).to.exist;
+        (0, chai_1.expect)(client.permissions).to.exist;
+        (0, chai_1.expect)(client.processors).to.exist;
+        (0, chai_1.expect)(client.turn).to.exist;
+        (0, chai_1.expect)(client.agents).to.exist;
+        (0, chai_1.expect)(client.gateway).to.exist;
+    });
+});

package/dist/test/doover-data-provider.test.d.ts

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