doover-js 0.1.0

package/dist/viewer/doover-data-provider.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DooverDataProvider = void 0;
+const agents_api_1 = require("../apis/agents-api");
+const aggregates_api_1 = require("../apis/aggregates-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 gateway_client_1 = require("../gateway/gateway-client");
+const errors_1 = require("../http/errors");
+const rest_client_1 = require("../http/rest-client");
+const snowflake_1 = require("../utils/snowflake");
+const path_parsing_1 = require("./path-parsing");
+class DooverDataProvider {
+    constructor(config) {
+        this.config = config;
+        this.subscriptions = new Map();
+        this.rest = new rest_client_1.RestClient(config);
+        this.gateway = new gateway_client_1.GatewayClient(config);
+        this.agentsApi = new agents_api_1.AgentsApi(this.rest);
+        this.channelsApi = new channels_api_1.ChannelsApi(this.rest);
+        this.messagesApi = new messages_api_1.MessagesApi(this.rest);
+        this.aggregatesApi = new aggregates_api_1.AggregatesApi(this.rest);
+        this.connectionsApi = new connections_api_1.ConnectionsApi(this.rest);
+        this.gateway.on("messageCreate", (message) => {
+            const key = this.channelKey(message.channel.agent_id, message.channel.name);
+            const identifier = this.toIdentifier(message.channel.agent_id, message.channel.name);
+            this.subscriptions.get(key)?.forEach((entry) => entry.messageCallback(identifier, message));
+        });
+        this.gateway.on("channelSync", (event) => {
+            const key = this.channelKey(event.channel.agent_id, event.channel.name);
+            const identifier = this.toIdentifier(event.channel.agent_id, event.channel.name);
+            this.subscriptions.get(key)?.forEach((entry) => entry.aggregateCallback(identifier, event.aggregate));
+        });
+        this.gateway.on("aggregateUpdate", (event) => {
+            const key = this.channelKey(event.channel.agent_id, event.channel.name);
+            const identifier = this.toIdentifier(event.channel.agent_id, event.channel.name);
+            this.subscriptions.get(key)?.forEach((entry) => entry.aggregateCallback(identifier, event.aggregate));
+        });
+    }
+    getMe() {
+        return this.rest.get("/users/me", undefined, this.config.controlApiUrl);
+    }
+    getAgents() {
+        return this.rest.get("/agents", undefined, this.config.controlApiUrl);
+    }
+    async getChannels(identifier, options) {
+        if (!identifier.agentId) {
+            return undefined;
+        }
+        return this.channelsApi.listChannels(identifier.agentId, {
+            include_archived: options?.includeArchived,
+        });
+    }
+    createChannel(identifier, channelName, options) {
+        if (!identifier.agentId) {
+            throw new errors_1.DooverValidationError("Identifier must contain agentId");
+        }
+        return this.channelsApi.putChannel(identifier.agentId, channelName, {
+            is_private: options?.is_private ?? false,
+        });
+    }
+    archiveChannel(identifier) {
+        const validated = this.requireChannel(identifier);
+        return this.rest.post(`/agents/${validated.agentId}/channels/${validated.channelName}/archive`, {});
+    }
+    unarchiveChannel(identifier) {
+        const validated = this.requireChannel(identifier);
+        return this.rest.post(`/agents/${validated.agentId}/channels/${validated.channelName}/unarchive`, {});
+    }
+    getChannel(identifier) {
+        if (!identifier.agentId || !identifier.channelName) {
+            return Promise.resolve(undefined);
+        }
+        return this.channelsApi.getChannel(identifier.agentId, identifier.channelName);
+    }
+    async subscribeToChannel(identifier, callback, aggregateCallback) {
+        const validated = this.requireChannel(identifier);
+        const key = this.channelKey(validated.agentId, validated.channelName);
+        const entries = this.subscriptions.get(key) ?? [];
+        entries.push({ messageCallback: callback, aggregateCallback });
+        this.subscriptions.set(key, entries);
+        this.gateway.connect();
+        this.gateway.subscribe({
+            agent_id: validated.agentId,
+            name: validated.channelName,
+        });
+        return Promise.resolve();
+    }
+    async unsubscribeFromChannel(identifier, callback) {
+        const validated = this.requireChannel(identifier);
+        const key = this.channelKey(validated.agentId, validated.channelName);
+        const entries = this.subscriptions.get(key);
+        if (!entries) {
+            return Promise.reject(new errors_1.DooverValidationError("Not Currently Subscribed to Channel"));
+        }
+        const next = entries.filter((entry) => entry.messageCallback !== callback);
+        if (next.length === 0) {
+            this.subscriptions.delete(key);
+            this.gateway.unsubscribe({
+                agent_id: validated.agentId,
+                name: validated.channelName,
+            });
+        }
+        else {
+            this.subscriptions.set(key, next);
+        }
+        return Promise.resolve();
+    }
+    async getAggregate(identifier) {
+        if (!identifier.agentId || !identifier.channelName) {
+            return undefined;
+        }
+        const channel = await this.channelsApi.getChannel(identifier.agentId, identifier.channelName);
+        if (channel.aggregate) {
+            return channel.aggregate;
+        }
+        return this.aggregatesApi.getAggregate(identifier.agentId, identifier.channelName);
+    }
+    async getMessages(identifier, beforeId) {
+        if (!identifier.agentId || !identifier.channelName) {
+            return undefined;
+        }
+        const messages = await this.messagesApi.listMessages(identifier.agentId, identifier.channelName, {
+            before: beforeId ?? (0, snowflake_1.generateSnowflakeIdAtTime)(new Date()),
+            limit: 10,
+        });
+        return messages.reverse();
+    }
+    deleteMessage(identifier, messageId) {
+        const validated = this.requireChannel(identifier);
+        return this.messagesApi.deleteMessage(validated.agentId, validated.channelName, messageId);
+    }
+    sendMessage(identifier, message) {
+        const validated = this.requireChannel(identifier);
+        return this.messagesApi.postMessage(validated.agentId, validated.channelName, {
+            data: message,
+        });
+    }
+    updateAggregate(identifier, message) {
+        const validated = this.requireChannel(identifier);
+        return this.aggregatesApi.patchAggregate(validated.agentId, validated.channelName, message);
+    }
+    putAggregate(identifier, message) {
+        const validated = this.requireChannel(identifier);
+        return this.aggregatesApi.putAggregate(validated.agentId, validated.channelName, message);
+    }
+    getChannelSubscriptions(identifier) {
+        const validated = this.requireChannel(identifier);
+        return this.connectionsApi.getChannelSubscriptions(validated.agentId, validated.channelName);
+    }
+    getAgentConnections(identifier) {
+        if (!identifier.agentId) {
+            return Promise.reject(new errors_1.DooverValidationError("Invalid Identifier"));
+        }
+        return this.connectionsApi.getAgentConnections(identifier.agentId);
+    }
+    getIdentifierFromPath(path, searchParams) {
+        return (0, path_parsing_1.getIdentifierFromPath)(path, searchParams);
+    }
+    getAgentInfo(agentId) {
+        return Promise.resolve({
+            id: agentId,
+            name: agentId,
+            display_name: agentId,
+            type: "device",
+            fa_icon: "fa-solid fa-robot",
+            organisation: "Organisation",
+            group: "group",
+            archived: false,
+            fixed_location: { latitude: 0, longitude: 0 },
+            extra_config: {},
+        });
+    }
+    requireChannel(identifier) {
+        if (!identifier.agentId || !identifier.channelName) {
+            throw new errors_1.DooverValidationError("Identifier must contain agentId and channelName");
+        }
+        return {
+            agentId: identifier.agentId,
+            channelName: identifier.channelName,
+        };
+    }
+    channelKey(agentId, channelName) {
+        return `${agentId}/${channelName}`;
+    }
+    toIdentifier(agentId, channelName) {
+        return { agentId, channelName };
+    }
+}
+exports.DooverDataProvider = DooverDataProvider;

package/dist/viewer/path-parsing.d.ts

@@ -0,0 +1,5 @@
+import type { ChannelIdentifier } from "../types/viewer";
+export declare function getIdentifierFromPath<TIdentifier extends ChannelIdentifier>(path: string, _searchParams: URLSearchParams): {
+    identifier: TIdentifier;
+    aggregatePath?: string;
+};

package/dist/viewer/path-parsing.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdentifierFromPath = getIdentifierFromPath;
+function getIdentifierFromPath(path, _searchParams) {
+    const cleaned = path.replace(/^\/+|\/+$/g, "");
+    const parts = cleaned ? cleaned.split("/") : [];
+    if (parts.length === 1) {
+        return {
+            identifier: {
+                agentId: parts[0],
+                channelName: undefined,
+            },
+        };
+    }
+    if (parts.length === 2) {
+        return {
+            identifier: {
+                agentId: parts[0],
+                channelName: parts[1],
+            },
+        };
+    }
+    if (parts.length > 2) {
+        return {
+            identifier: {
+                agentId: parts[0],
+                channelName: parts[1],
+            },
+            aggregatePath: parts.slice(2).join("/"),
+        };
+    }
+    return {
+        identifier: {
+            agentId: undefined,
+            channelName: undefined,
+        },
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "doover-js",
+  "version": "0.1.0",
+  "description": "TypeScript client for Doover.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/get-doover/doover-js.git"
+  },
+  "homepage": "https://github.com/get-doover/doover-js#readme",
+  "bugs": {
+    "url": "https://github.com/get-doover/doover-js/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "test": "mocha --require tsx/cjs \"src/test/**/*.test.ts\""
+  },
+  "keywords": [
+    "doover"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/chai": "^5.2.2",
+    "@types/chai-as-promised": "^7.1.8",
+    "@types/mocha": "^10.0.10",
+    "@types/sinon": "^17.0.4",
+    "chai": "^5.2.1",
+    "chai-as-promised": "^8.0.2",
+    "mocha": "^11.1.0",
+    "sinon": "^21.0.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  }
+}