@dronedeploy/rocos-js-sdk 0.0.1 → 1.0.0-alpha-2

package/IRocosSDK.d.ts

@@ -0,0 +1,55 @@
+import { MapService, SpotProvisioningServiceNode } from './services';
+import { AssetStorageService } from './services/AssetStorageService';
+import { AuthService } from './services/AuthService';
+import { CallerService } from './services/CallerService';
+import { CommandService } from './services/CommandService';
+import { ConfigGroupService } from './services/ConfigGroupService';
+import { ControlService } from './services/ControlService';
+import { DashboardService } from './services/DashboardService';
+import { EventService } from './services/EventService';
+import { FileAccessorService } from './services/FileAccessorService';
+import { FunctionService } from './services/FunctionService';
+import { IBaseService } from './models/IBaseService';
+import { IDebugLevel } from './models/IDebugLevel';
+import { IntegrationService } from './services/IntegrationService';
+import { ProfileService } from './services/ProfileService';
+import { ProjectService } from './services/ProjectService';
+import { RobotService } from './services/RobotService';
+import { SearchService } from './services/SearchService';
+import { ServiceEnum } from './models/ServiceEnum';
+import { SpotProvisioningService } from './services/SpotProvisioningService';
+import { StreamService } from './services/StreamService';
+import { TelemetryService } from './services/TelemetryService';
+import { TimeSyncerService } from './services/TimeSyncerService';
+import { UserService } from './services/UserService';
+import { WebRTCSignallingService } from './services/WebRTCSignallingService';
+import { WorkflowService } from './services/WorkflowService';
+export declare abstract class IRocosSDK {
+    abstract getService<T extends IBaseService>(name: ServiceEnum): T;
+    abstract getAuthService(): AuthService;
+    abstract getRobotService(): RobotService;
+    abstract getEventService(): EventService;
+    abstract getProjectService(): ProjectService;
+    abstract getTelemetryService(): TelemetryService;
+    abstract getCallerService(): CallerService;
+    abstract getControlService(): ControlService;
+    abstract getCommandService(): CommandService;
+    abstract getSearchService(): SearchService;
+    abstract getConfigGroupService(): ConfigGroupService;
+    abstract getDashboardService(): DashboardService;
+    abstract getFunctionService(): FunctionService;
+    abstract getStreamService(): StreamService;
+    abstract getUserService(): UserService;
+    abstract getMapService(): MapService;
+    abstract getTimeSyncerService(): TimeSyncerService;
+    abstract getWorkflowService(): WorkflowService;
+    abstract getAssetStorageService(): AssetStorageService;
+    abstract getProfileService(): ProfileService;
+    abstract getWebRTCSignallingService(): WebRTCSignallingService;
+    abstract getFileAccessorService(): FileAccessorService;
+    abstract getSpotProvisionerService(): SpotProvisioningService | SpotProvisioningServiceNode;
+    abstract getIntegrationService(): IntegrationService;
+    abstract cleanup(): Promise<boolean>;
+    abstract enableDebugMode(on: boolean): void;
+    abstract setDebugLevel(level: IDebugLevel): void;
+}

package/IRocosSDK.js

@@ -0,0 +1,2 @@
+export class IRocosSDK {
+}

package/README.md

@@ -0,0 +1,108 @@
+# rocos-js-sdk
+Javascript SDK for interacting with the Rocos platform.
+
+## Using with Node
+In order to use the SDK with node, you must be using node version 18.13 or higher.
+
+## Installation
+
+Add a .npmrc to your project, in the same directory as your package.json
+
+```bash
+@team-rocos:registry=https://npm.pkg.github.com
+```
+
+Then install the package with npm
+
+```bash
+npm install @team-rocos/rocos-js-sdk
+```
+
+or yarn
+
+```bash
+yarn add @team-rocos/rocos-js-sdk rxjs@^7
+```
+## What's New?
+
+### 3.0.0
+
+*Breaking Changes*
+* `IToken` interface changes
+  * `created` is now `issuedAt` and is a `Date` object instead of a `string`
+  * `expiresIn` is now `expires` and is a `Date` object instead of a `number`
+* `Token` class is now only functional for JWT tokens
+* Logging in and signing up with email and password has been removed
+* Resetting password has been removed
+
+*New Features*
+* NodeJS requirement has been dropped, so that the SDK can be used in the browser regardless of node version. When using node SDK, you must be using node version 18.13 or higher.
+* `AuthService` now supports `refreshToken` method to refresh the access token
+* Auth Token will now be refreshed automatically when it expires
+
+
+### 2.6.1
+
+* Modify map service response type
+
+### 2.6.0
+
+* Change `rxjs` dependency to a peer dependency (support for `^6.6.6 || ^7.0.0`)
+  - If you are using `yarn` you may need to add `rxjs` to your dependencies
+
+### 2.4.0
+
+* deleted unused endpoints relating to legacy accounts which are no longer supported
+
+### 2.3.0
+
+* Added `mapService` for supporting agent map functionality
+
+### 2.2.0
+
+* Added `listUsers` method in ProjectService to list project users
+* Added additional debug information for failed HTTP responses
+
+### 2.1.0
+
+* Added getPlansPaged method to the IntegrationService to retrieve plans in a paged manner
+
+### 2.0.2
+
+* Fix no-content responses attempting to parse as JSON
+
+### 2.0.1
+
+* Security updates for React demo app dependencies
+
+### 2.0.0
+
+* Updating base class for all REST requests to go via fetch instead of axios
+* Remove unused dependencies `source-map-loader`, `ts-loader`, `axios`
+* Mark certain auth methods as deprecated in AuthService
+  * `login` Login with email and password.
+  * `signup`
+  * `resetPassword`
+* Deleted legacy services, these services are prefixed with BC, e.g. `BCRocosClient`
+* Updated outdated dependencies in the Angular demo application
+
+#### Migrating from 1.x to 2.x
+
+* NodeJS engine requirements need to be v18.13 and npm v8 to use in NodeJS as the underlying HTTP services now use fetch API
+* Legacy services prefixed with BC will need to be migrated to use the standard services
+
+### 1.19.0
+
+New method added to the `IntegrationService` to create a new issue in the current location. 
+
+* createIssue - Creates a new issue in a specific location on the latest map plan
+
+### 1.18.0
+
+Added new integration service to be able to retrieve plans created in DroneDeploy
+
+This can be retrieved by getIntegrationService(). Available methods:
+
+* getPlans - Gets a list of plans
+* getPlanById - Retrieves a specific plan with the tiled layer that can be used to render meshes, point clouds, or tiled maps
+* getWMTS - Returns WMTS tiles that can be rendered in tools such as mapbox if your project has WMTS feature enabled)

package/RocosSDK.d.ts

@@ -0,0 +1,138 @@
+import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, ProfileService, ProjectService, RobotService, ScheduleService, SearchService, SpotProvisioningService, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService } from './services';
+import { IBaseService, IDebugLevel, IRocosSDKConfig, ServiceEnum } from './models';
+import { IRocosSDK } from './IRocosSDK';
+import { Logger } from 'loglevel';
+export declare class RocosSDK implements IRocosSDK {
+    protected config: IRocosSDKConfig;
+    protected logger: Logger;
+    protected services: Record<string, IBaseService>;
+    /**
+     * Create a new SDK instance using a config object.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     */
+    constructor(config: IRocosSDKConfig);
+    /**
+     * Gets the service by service name.
+     *
+     * @param name - Service name {@link ServiceEnum}
+     */
+    getService<T extends IBaseService>(name: ServiceEnum): T;
+    /**
+     * GEts the authentication service.
+     */
+    getAuthService(): AuthService;
+    /**
+     * Gets the robot service.
+     */
+    getRobotService(): RobotService;
+    /**
+     * Gets the event service.
+     */
+    getEventService(): EventService;
+    /**
+     * Gets the project service.
+     */
+    getProjectService(): ProjectService;
+    /**
+     * Gets the telemetry service.
+     */
+    getTelemetryService(): TelemetryService;
+    /**
+     * Gets the service call service.
+     */
+    getCallerService(): CallerService;
+    /**
+     * Gets the command service.
+     */
+    getCommandService(): CommandService;
+    /**
+     * Gets the robot control service.
+     */
+    getControlService(): ControlService;
+    /**
+     * Gets the search service.
+     */
+    getSearchService(): SearchService;
+    /**
+     * Gets the config group service
+     */
+    getConfigGroupService(): ConfigGroupService;
+    /**
+     * Gets the dashboard service
+     */
+    getDashboardService(): DashboardService;
+    /**
+     * Gets the function service
+     */
+    getFunctionService(): FunctionService;
+    /**
+     * Gets the stream service
+     */
+    getStreamService(): StreamService;
+    /**
+     * Gets the user service
+     */
+    getUserService(): UserService;
+    /**
+     * Gets time syncer service
+     */
+    getTimeSyncerService(): TimeSyncerService;
+    /**
+     * Gets the workflow service
+     */
+    getWorkflowService(): WorkflowService;
+    /**
+     * Gets the asset storage service
+     */
+    getAssetStorageService(): AssetStorageService;
+    /**
+     * Gets the robot profile service
+     */
+    getProfileService(): ProfileService;
+    /**
+     * Gets the WebRTC signalling service
+     * @returns WebRTCSignallingService
+     */
+    getWebRTCSignallingService(): WebRTCSignallingService;
+    /**
+     * Gets the file accessor service
+     * @returns FileAccessorService
+     */
+    getFileAccessorService(): FileAccessorService;
+    /**
+     * Gets the scheduler service
+     * @returns FileAccessorService
+     */
+    getSchedulerService(): ScheduleService;
+    /**
+     * Gets the spot provisioner service
+     * @returns SpotProvisioningService
+     */
+    getSpotProvisionerService(): SpotProvisioningService;
+    /**
+     * Gets the integration service
+     * @returns IntegrationService
+     */
+    getIntegrationService(): IntegrationService;
+    /**
+     * Gets the map service
+     * @returns MapService
+     */
+    getMapService(): MapService;
+    get platformTimeOffset(): number;
+    get platformTime(): number;
+    /**
+     * Cleanup function to release all the stream resources.
+     * All streams get destroyed by default once all the observers unsubscribe.
+     * This should be called as a precaution in case there are some subscriptions still hanging.
+     */
+    cleanup(): Promise<boolean>;
+    /**
+     * Enable or disable debug log
+     *
+     * @param on
+     */
+    enableDebugMode(on: boolean): void;
+    setDebugLevel(level: IDebugLevel): void;
+}

package/RocosSDK.js

@@ -0,0 +1,292 @@
+import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, PlatFormTimeService, ProfileService, ProjectService, RobotService, ScheduleService, SearchService, SpotProvisioningService, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService, } from './services';
+import { ServiceEnum } from './models';
+import { RocosLogger } from './logger/RocosLogger';
+import { RocosStore } from './store/RocosStore';
+import { StreamRegister } from './api/StreamRegister';
+export class RocosSDK {
+    /**
+     * Create a new SDK instance using a config object.
+     *
+     * @param config - SDK config {@link IRocosSDKConfig}
+     */
+    constructor(config) {
+        this.services = {};
+        this.config = config;
+        this.logger = RocosLogger.getInstance(`RocosSDK(${this.config.url})`);
+        RocosStore.putSDKInstance(this.config, this);
+    }
+    /**
+     * Gets the service by service name.
+     *
+     * @param name - Service name {@link ServiceEnum}
+     */
+    // eslint-disable-next-line max-lines-per-function
+    getService(name) {
+        if (!this.services?.[name]) {
+            this.logger.info(`Service ${name} does not exist, creating it now.`);
+            switch (name) {
+                case ServiceEnum.AUTH:
+                    this.services[name] = new AuthService(this.config);
+                    break;
+                case ServiceEnum.TELEMETRY:
+                    this.services[name] = new TelemetryService(this.config);
+                    break;
+                case ServiceEnum.ROBOT:
+                    this.services[name] = new RobotService(this.config);
+                    break;
+                case ServiceEnum.EVENT:
+                    this.services[name] = new EventService(this.config);
+                    break;
+                case ServiceEnum.PROJECT:
+                    this.services[name] = new ProjectService(this.config);
+                    break;
+                case ServiceEnum.CALLER:
+                    this.services[name] = new CallerService(this.config);
+                    break;
+                case ServiceEnum.COMMAND:
+                    this.services[name] = new CommandService(this.config);
+                    break;
+                case ServiceEnum.CONTROL:
+                    this.services[name] = new ControlService(this.config);
+                    break;
+                case ServiceEnum.SEARCH:
+                    this.services[name] = new SearchService(this.config);
+                    break;
+                case ServiceEnum.CONFIG_GROUP:
+                    this.services[name] = new ConfigGroupService(this.config);
+                    break;
+                case ServiceEnum.DASHBOARD:
+                    this.services[name] = new DashboardService(this.config);
+                    break;
+                case ServiceEnum.FUNCTION:
+                    this.services[name] = new FunctionService(this.config);
+                    break;
+                case ServiceEnum.STREAM:
+                    this.services[name] = new StreamService(this.config);
+                    break;
+                case ServiceEnum.USER:
+                    this.services[name] = new UserService(this.config);
+                    break;
+                case ServiceEnum.TIME_SYNCER:
+                    this.services[name] = new TimeSyncerService(this.config);
+                    break;
+                case ServiceEnum.WORKFLOW:
+                    this.services[name] = new WorkflowService(this.config);
+                    break;
+                case ServiceEnum.ASSET_STORAGE:
+                    this.services[name] = new AssetStorageService(this.config);
+                    break;
+                case ServiceEnum.PROFILE:
+                    this.services[name] = new ProfileService(this.config);
+                    break;
+                case ServiceEnum.WEBRTC_SIGNALLING:
+                    this.services[name] = new WebRTCSignallingService(this.config);
+                    break;
+                case ServiceEnum.FILE_ACCESSOR:
+                    this.services[name] = new FileAccessorService(this.config);
+                    break;
+                case ServiceEnum.SCHEDULE:
+                    this.services[name] = new ScheduleService(this.config);
+                    break;
+                case ServiceEnum.SPOT_PROVISIONER:
+                    this.services[name] = new SpotProvisioningService(this.config);
+                    break;
+                case ServiceEnum.INTEGRATION:
+                    this.services[name] = new IntegrationService(this.config);
+                    break;
+                case ServiceEnum.MAP:
+                    this.services[name] = new MapService(this.config);
+                    break;
+            }
+        }
+        this.logger.debug(`Found service ${name}.`);
+        return this.services[name];
+    }
+    /**
+     * GEts the authentication service.
+     */
+    getAuthService() {
+        return this.getService(ServiceEnum.AUTH);
+    }
+    /**
+     * Gets the robot service.
+     */
+    getRobotService() {
+        return this.getService(ServiceEnum.ROBOT);
+    }
+    /**
+     * Gets the event service.
+     */
+    getEventService() {
+        return this.getService(ServiceEnum.EVENT);
+    }
+    /**
+     * Gets the project service.
+     */
+    getProjectService() {
+        return this.getService(ServiceEnum.PROJECT);
+    }
+    /**
+     * Gets the telemetry service.
+     */
+    getTelemetryService() {
+        return this.getService(ServiceEnum.TELEMETRY);
+    }
+    /**
+     * Gets the service call service.
+     */
+    getCallerService() {
+        return this.getService(ServiceEnum.CALLER);
+    }
+    /**
+     * Gets the command service.
+     */
+    getCommandService() {
+        return this.getService(ServiceEnum.COMMAND);
+    }
+    /**
+     * Gets the robot control service.
+     */
+    getControlService() {
+        return this.getService(ServiceEnum.CONTROL);
+    }
+    /**
+     * Gets the search service.
+     */
+    getSearchService() {
+        return this.getService(ServiceEnum.SEARCH);
+    }
+    /**
+     * Gets the config group service
+     */
+    getConfigGroupService() {
+        return this.getService(ServiceEnum.CONFIG_GROUP);
+    }
+    /**
+     * Gets the dashboard service
+     */
+    getDashboardService() {
+        return this.getService(ServiceEnum.DASHBOARD);
+    }
+    /**
+     * Gets the function service
+     */
+    getFunctionService() {
+        return this.getService(ServiceEnum.FUNCTION);
+    }
+    /**
+     * Gets the stream service
+     */
+    getStreamService() {
+        return this.getService(ServiceEnum.STREAM);
+    }
+    /**
+     * Gets the user service
+     */
+    getUserService() {
+        return this.getService(ServiceEnum.USER);
+    }
+    /**
+     * Gets time syncer service
+     */
+    getTimeSyncerService() {
+        return this.getService(ServiceEnum.TIME_SYNCER);
+    }
+    /**
+     * Gets the workflow service
+     */
+    getWorkflowService() {
+        return this.getService(ServiceEnum.WORKFLOW);
+    }
+    /**
+     * Gets the asset storage service
+     */
+    getAssetStorageService() {
+        return this.getService(ServiceEnum.ASSET_STORAGE);
+    }
+    /**
+     * Gets the robot profile service
+     */
+    getProfileService() {
+        return this.getService(ServiceEnum.PROFILE);
+    }
+    /**
+     * Gets the WebRTC signalling service
+     * @returns WebRTCSignallingService
+     */
+    getWebRTCSignallingService() {
+        return this.getService(ServiceEnum.WEBRTC_SIGNALLING);
+    }
+    /**
+     * Gets the file accessor service
+     * @returns FileAccessorService
+     */
+    getFileAccessorService() {
+        return this.getService(ServiceEnum.FILE_ACCESSOR);
+    }
+    /**
+     * Gets the scheduler service
+     * @returns FileAccessorService
+     */
+    getSchedulerService() {
+        return this.getService(ServiceEnum.SCHEDULE);
+    }
+    /**
+     * Gets the spot provisioner service
+     * @returns SpotProvisioningService
+     */
+    getSpotProvisionerService() {
+        return this.getService(ServiceEnum.SPOT_PROVISIONER);
+    }
+    /**
+     * Gets the integration service
+     * @returns IntegrationService
+     */
+    getIntegrationService() {
+        return this.getService(ServiceEnum.INTEGRATION);
+    }
+    /**
+     * Gets the map service
+     * @returns MapService
+     */
+    getMapService() {
+        return this.getService(ServiceEnum.MAP);
+    }
+    get platformTimeOffset() {
+        return PlatFormTimeService.getInstance(this.getTimeSyncerService())?.platformTimeOffset;
+    }
+    get platformTime() {
+        return PlatFormTimeService.getInstance(this.getTimeSyncerService())?.platformTime;
+    }
+    /**
+     * Cleanup function to release all the stream resources.
+     * All streams get destroyed by default once all the observers unsubscribe.
+     * This should be called as a precaution in case there are some subscriptions still hanging.
+     */
+    async cleanup() {
+        for (const service of Object.values(this.services)) {
+            if (service.teardown) {
+                await service.teardown();
+            }
+        }
+        this.services = {};
+        RocosStore.removeSDKInstance(this.config);
+        return StreamRegister.getInstance().removeAllStreams();
+    }
+    /**
+     * Enable or disable debug log
+     *
+     * @param on
+     */
+    enableDebugMode(on) {
+        if (on) {
+            RocosLogger.enableAll();
+        }
+        else {
+            RocosLogger.disableAll();
+        }
+    }
+    setDebugLevel(level) {
+        RocosLogger.setLevel(level);
+    }
+}

package/api/StreamRegister.d.ts

@@ -0,0 +1,13 @@
+import { IBaseStream } from '../models';
+export declare class StreamRegister {
+    private teleStreams;
+    private logger;
+    private static instance;
+    private constructor();
+    static getInstance(): StreamRegister;
+    static getIdentifier($identifier: string, scope?: string): string;
+    addStream(stream: IBaseStream): Promise<void>;
+    getStream(identifier: string): IBaseStream | undefined;
+    removeStream(stream: IBaseStream): Promise<void>;
+    removeAllStreams(): Promise<boolean>;
+}

package/api/StreamRegister.js

@@ -0,0 +1,69 @@
+import { RocosError, errorCodes } from '../models';
+import { RocosLogger } from '../logger/RocosLogger';
+export class StreamRegister {
+    constructor() {
+        this.teleStreams = new Map();
+        this.logger = RocosLogger.getInstance('StreamRegister');
+    }
+    static getInstance() {
+        if (!StreamRegister.instance) {
+            StreamRegister.instance = new StreamRegister();
+        }
+        return StreamRegister.instance;
+    }
+    static getIdentifier($identifier, scope) {
+        return `${$identifier}-${scope ?? ''}`;
+    }
+    async addStream(stream) {
+        try {
+            if (this.teleStreams.has(stream.identifier)) {
+                await this.removeStream(stream);
+            }
+            this.teleStreams.set(stream.identifier, stream);
+        }
+        catch (e) {
+            this.logger.error(`Failed to add stream to list. identifier: ${stream.identifier}`, e);
+            if (e instanceof Error || typeof e === 'string') {
+                throw new RocosError(e, errorCodes.STREAM_LISTENER_ERROR);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    getStream(identifier) {
+        return this.teleStreams.get(identifier);
+    }
+    async removeStream(stream) {
+        try {
+            await stream.stopStream();
+            this.teleStreams.delete(stream.identifier);
+        }
+        catch (e) {
+            this.logger.error(`Failed to remove stream from list. identifier: ${stream.identifier}`, e);
+            if (e instanceof Error || typeof e === 'string') {
+                throw new RocosError(e, errorCodes.STREAM_LISTENER_ERROR);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async removeAllStreams() {
+        try {
+            for (const [, stream] of this.teleStreams.entries()) {
+                await this.removeStream(stream);
+            }
+        }
+        catch (e) {
+            this.logger.error(`error removing stream, ${e}`);
+            if (e instanceof Error || typeof e === 'string') {
+                throw new RocosError(e, errorCodes.STREAM_LISTENER_ERROR);
+            }
+            else {
+                throw e;
+            }
+        }
+        return true;
+    }
+}