@dronedeploy/rocos-js-sdk 3.0.1-alpha.2 → 3.0.1-alpha.20

package/services/BaseServiceAbstract.d.ts

@@ -1,36 +0,0 @@
-import { IRocosSDKConfig, RocosError } from '../models';
-import { QueryParams } from '../helpers';
-import { Logger } from 'loglevel';
-type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
-interface RequestConfig {
-    /**
-     * Additional headers to send with the request.
-     */
-    headers?: Record<string, string>;
-    /**
-     * If true, the request will be sent without authentication.
-     */
-    public?: boolean;
-    /**
-     * The response type to use for the request.
-     */
-    responseType?: ResponseType;
-}
-export declare abstract class BaseServiceAbstract {
-    protected config: IRocosSDKConfig;
-    protected logger: Logger;
-    protected constructor(config: IRocosSDKConfig);
-    protected abstract getError(e: Error): RocosError;
-    protected callPost<Response = unknown, Payload = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<Response>;
-    protected callPut<Response = unknown, Payload = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<Response>;
-    protected callDelete<Response = unknown, Payload = unknown>(url: string, errorMessage: string, payload?: Payload): Promise<Response>;
-    protected callGet<Response = unknown>(url: string, errorMessage: string, params?: QueryParams, config?: RequestConfig): Promise<Response>;
-    protected call<Response = unknown, Payload = unknown>(url: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE', options: {
-        errorMessage: string;
-        config?: RequestConfig;
-        payload?: Payload;
-        params?: QueryParams;
-    }): Promise<Response>;
-    private fetchOrThrow;
-}
-export {};

package/services/BaseServiceAbstract.js

@@ -1,97 +0,0 @@
-import { RocosError } from '../models';
-import { getURLSearchParams } from '../helpers';
-import { RocosStore } from '../store/RocosStore';
-class HttpError extends Error {
-    constructor(response) {
-        super(response.statusText);
-        this.response = response;
-        this.name = 'HttpError';
-    }
-}
-export class BaseServiceAbstract {
-    constructor(config) {
-        this.config = config;
-    }
-    async callPost(url, payload, errorMessage, config) {
-        return this.call(url, 'POST', { errorMessage, payload, config });
-    }
-    async callPut(url, payload, errorMessage, config) {
-        return this.call(url, 'PUT', { errorMessage, payload, config });
-    }
-    async callDelete(url, errorMessage, payload) {
-        return this.call(url, 'DELETE', { errorMessage, payload });
-    }
-    async callGet(url, errorMessage, params, config) {
-        return this.call(url, 'GET', { errorMessage, params, config });
-    }
-    async call(url, method, options) {
-        const { errorMessage, config, payload, params } = options;
-        try {
-            const formattedUrl = params ? `${url}?${getURLSearchParams(params)}` : url;
-            const defaultHeaders = {};
-            if (!config?.public) {
-                const token = await RocosStore.getSDKInstance(this.config).getAuthService().getToken();
-                defaultHeaders.Authorization = token.bearer;
-            }
-            const requestConfig = {
-                method,
-                headers: {
-                    ...defaultHeaders,
-                    ...config?.headers,
-                },
-            };
-            // must check if FormData exists for node support
-            if (typeof FormData !== 'undefined' && payload instanceof FormData) {
-                requestConfig.body = payload;
-            }
-            else if (payload) {
-                requestConfig.body = JSON.stringify(payload);
-                requestConfig.headers = { ...requestConfig.headers, 'Content-Type': 'application/json' };
-            }
-            return this.fetchOrThrow(formattedUrl, requestConfig, config?.responseType);
-        }
-        catch (e) {
-            const message = errorMessage;
-            this.logger.error(message, e);
-            let httpError = new RocosError(message);
-            if (e instanceof HttpError) {
-                httpError = this.getError(e);
-                httpError.statusCode = e?.response?.status;
-            }
-            RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
-            throw httpError;
-        }
-    }
-    async fetchOrThrow(url, config, responseType) {
-        this.logger.debug('Fetching', { url, config });
-        const res = await fetch(url, config);
-        if (!res.ok) {
-            const payload = await res.text();
-            this.logger.warn('Failed HTTP Response', { status: res.statusText, payload, response: res });
-            throw new HttpError(res);
-        }
-        switch (responseType) {
-            case 'raw':
-                return res;
-            case 'stream':
-                return res.body;
-            case 'blob':
-                return res.blob();
-            case 'text':
-                return res.text();
-            case 'json':
-            default: {
-                const textRes = await res.text();
-                if (!textRes?.trim())
-                    return undefined;
-                try {
-                    return JSON.parse(textRes);
-                }
-                catch (e) {
-                    this.logger.error('Failed to parse JSON from response', { textRes });
-                    return textRes;
-                }
-            }
-        }
-    }
-}

package/services/BaseStreamService.js

@@ -1,47 +0,0 @@
-import { SubscriberStatusEnum, Token } from '../models';
-import { RocosLogger } from '../logger/RocosLogger';
-import { RocosStore } from '../store/RocosStore';
-import { StreamRegister } from '../api/StreamRegister';
-import { Subject } from 'rxjs';
-export class BaseStreamService {
-    constructor(name, config) {
-        this.status = false;
-        this.status$ = new Subject();
-        this.config = config;
-        this.logger = RocosLogger.getInstance(`${name}(${this.config.url})`);
-    }
-    getStatus() {
-        return this.status;
-    }
-    async initStream(stream) {
-        const authService = RocosStore.getSDKInstance(this.config).getAuthService();
-        if (!this.config.token || !authService.isTokenValid(new Token(this.config.token))) {
-            try {
-                const token = await authService.getToken();
-                stream.setToken(token.value);
-            }
-            catch (e) {
-                this.logger.error('Can not retrieve auth token', e);
-                throw new Error('Can not retrieve auth token');
-            }
-        }
-        authService.startTokenRefreshChecker();
-    }
-    async createStreamFromConfig(identifier, config) {
-        const identifierWithScope = StreamRegister.getIdentifier(identifier);
-        const streamRegister = StreamRegister.getInstance();
-        let stream = streamRegister.getStream(identifierWithScope);
-        let isNew = false;
-        if (!stream) {
-            isNew = true;
-            stream = this.getStream(config);
-            stream.statusStream$.subscribe((msg) => {
-                this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
-                this.status$.next(msg);
-            });
-            await streamRegister.addStream(stream);
-            await this.initStream(stream);
-        }
-        return { stream, isNew };
-    }
-}

package/services/CallerService.d.ts

@@ -1,10 +0,0 @@
-import { ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IRocosSDKConfig, IStreamConfig } from '../models';
-import { Observable } from 'rxjs';
-import { BaseStreamService } from './BaseStreamService';
-export declare class CallerService extends BaseStreamService<ICallerStream> {
-    constructor(config: IRocosSDKConfig);
-    invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
-    cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
-    protected createStream(): Promise<ICallerStream>;
-    protected getStream(config: IStreamConfig): ICallerStream;
-}

package/services/CallerService.js

@@ -1,53 +0,0 @@
-import { Subject } from 'rxjs';
-import { BaseStreamService } from './BaseStreamService';
-import { CallerStream } from '../api/streams/caller/CallerStream';
-import { IDENTIFIER_NAME_CALLER } from '../constants/identifier';
-import { finalize } from 'rxjs/operators';
-export class CallerService extends BaseStreamService {
-    constructor(config) {
-        super('CallerService', config);
-    }
-    invokeRequest(params) {
-        const subject = new Subject();
-        let subscription;
-        this.createStream()
-            .then((stream) => {
-            subscription = stream.invokeRequest(params).subscribe(subject);
-        })
-            .catch((e) => {
-            this.logger.info('invokeRequest error', e);
-            subject.error(e);
-        });
-        return subject.asObservable().pipe(finalize(() => {
-            subscription?.unsubscribe();
-        }));
-    }
-    cancelRequest(params) {
-        const subject = new Subject();
-        let subscription;
-        this.createStream()
-            .then((stream) => {
-            subscription = stream.cancelRequest(params).subscribe(subject);
-        })
-            .catch((e) => {
-            this.logger.info('invokeRequest error', e);
-            subject.error(e);
-        });
-        return subject.asObservable().pipe(finalize(() => {
-            subscription?.unsubscribe();
-        }));
-    }
-    async createStream() {
-        return (await this.createStreamFromConfig(IDENTIFIER_NAME_CALLER, {
-            url: this.config.url,
-            token: this.config.token,
-            scope: 'default',
-            options: this.config.options,
-            port: this.config.port,
-            insecure: this.config.insecure,
-        })).stream;
-    }
-    getStream(config) {
-        return new CallerStream(config);
-    }
-}

package/services/EvaluatorService.js

@@ -1,28 +0,0 @@
-import { RocosError, errorCodes } from '../models';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-import { RocosLogger } from '../logger/RocosLogger';
-import { WebSandbox } from '../helpers';
-export class EvaluatorService extends BaseServiceAbstract {
-    constructor(config) {
-        super(config);
-        this.logger = RocosLogger.getInstance(`EvaluatorService(${this.config.url})`);
-        this.sandbox = WebSandbox.new().catch((e) => {
-            this.logger.error('Failed to create WebSandbox', e);
-            throw e;
-        });
-    }
-    getError(e) {
-        return new RocosError(e, errorCodes.EVALUATOR_SERVICE_ERROR);
-    }
-    getStatus() {
-        return true;
-    }
-    async teardown() {
-        const sandbox = await this.sandbox;
-        sandbox.destroy();
-    }
-    async execute(code, context, options) {
-        const sandbox = await this.sandbox;
-        return sandbox.run(code, context, options);
-    }
-}

package/services/FunctionService.d.ts

@@ -1,68 +0,0 @@
-import { RocosError } from '../models/RocosError';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-import { IBaseService } from '../models/IBaseService';
-import { IExportDataQuery } from '../models/IExportDataQuery';
-import { IFunctionConfig } from '../models/IFunctionConfig';
-import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
-export declare class FunctionService extends BaseServiceAbstract implements IBaseService {
-    constructor(config: IRocosSDKConfig);
-    protected getError(e: Error): RocosError;
-    getStatus(): boolean;
-    /**
-     * Export data
-     *
-     * @param projectId - Project Id
-     * @param query - Payload {@link IExportDataQuery}
-     */
-    exportJobs(projectId: string, query: IExportDataQuery): Promise<any>;
-    /**
-     * Create a function
-     *
-     * @param projectId - Project Id
-     * @param model - Payload {@link IFunctionConfig}
-     */
-    create(projectId: string, model: IFunctionConfig): Promise<any>;
-    /**
-     * Get a functions
-     *
-     * @param projectId - Project Id
-     */
-    list(projectId: string): Promise<any>;
-    /**
-     * Update a function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     * @param model - Payload {@link IFunctionConfig}
-     */
-    update(projectId: string, functionId: string, model: IFunctionConfig): Promise<any>;
-    /**
-     * Get function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     */
-    info(projectId: string, functionId: string): Promise<any>;
-    /**
-     * Delete function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     */
-    delete(projectId: string, functionId: string): Promise<any>;
-    /**
-     * Run a function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     * @param body - Payload
-     */
-    run(projectId: string, functionId: string, body?: any): Promise<any>;
-    /**
-     * Get function pods
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     */
-    pods(projectId: string, functionId: string): Promise<any>;
-}

package/services/FunctionService.js

@@ -1,99 +0,0 @@
-import { API_PROJECT_EXPORT_URL, API_PROJECT_FUNCTION_ID_URL, API_PROJECT_FUNCTION_POD_URL, API_PROJECT_FUNCTION_RUN_URL, API_PROJECT_FUNCTION_URL, } from '../constants/api';
-import { RocosError, errorCodes } from '../models/RocosError';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-import { ExportDataQuery } from '../models/ExportDataQuery';
-import { RocosLogger } from '../logger/RocosLogger';
-import { formatServiceUrl } from '../helpers/formatServiceUrl';
-export class FunctionService extends BaseServiceAbstract {
-    constructor(config) {
-        super(config);
-        this.logger = RocosLogger.getInstance(`FunctionService(${this.config.url})`);
-    }
-    getError(e) {
-        return new RocosError(e, errorCodes.FUNCTION_SERVICE_ERROR);
-    }
-    getStatus() {
-        return true;
-    }
-    /**
-     * Export data
-     *
-     * @param projectId - Project Id
-     * @param query - Payload {@link IExportDataQuery}
-     */
-    // TODO: map the response object
-    async exportJobs(projectId, query) {
-        return this.callPost(formatServiceUrl(API_PROJECT_EXPORT_URL, { url: this.config.url, projectId }, this.config.insecure), new ExportDataQuery(query).toJSON(), `Failed to export data for ${projectId}.`);
-    }
-    /**
-     * Create a function
-     *
-     * @param projectId - Project Id
-     * @param model - Payload {@link IFunctionConfig}
-     */
-    // TODO: map the response object
-    async create(projectId, model) {
-        return this.callPost(formatServiceUrl(API_PROJECT_FUNCTION_URL, { url: this.config.url, projectId }, this.config.insecure), model, `Failed to create function for ${projectId}.`);
-    }
-    /**
-     * Get a functions
-     *
-     * @param projectId - Project Id
-     */
-    // TODO: map the response object
-    async list(projectId) {
-        return this.callGet(formatServiceUrl(API_PROJECT_FUNCTION_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get functions for ${projectId}.`);
-    }
-    /**
-     * Update a function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     * @param model - Payload {@link IFunctionConfig}
-     */
-    // TODO: map the response object
-    async update(projectId, functionId, model) {
-        return this.callPut(formatServiceUrl(API_PROJECT_FUNCTION_ID_URL, { url: this.config.url, projectId, functionId }, this.config.insecure), model, `Failed to update function for ${projectId}, functionId ${functionId}.`);
-    }
-    /**
-     * Get function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     */
-    // TODO: map the response object
-    async info(projectId, functionId) {
-        return this.callGet(formatServiceUrl(API_PROJECT_FUNCTION_ID_URL, { url: this.config.url, projectId, functionId }, this.config.insecure), `Failed to get function for ${projectId}, functionId ${functionId}.`);
-    }
-    /**
-     * Delete function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     */
-    // TODO: map the response object
-    async delete(projectId, functionId) {
-        return this.callDelete(formatServiceUrl(API_PROJECT_FUNCTION_ID_URL, { url: this.config.url, projectId, functionId }, this.config.insecure), `Failed to delete function for ${projectId}, functionId ${functionId}.`);
-    }
-    /**
-     * Run a function
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     * @param body - Payload
-     */
-    // TODO: map the response object
-    async run(projectId, functionId, body = null) {
-        return this.callPost(formatServiceUrl(API_PROJECT_FUNCTION_RUN_URL, { url: this.config.url, projectId, functionId }, this.config.insecure), body, `Failed to run function for ${projectId}, functionId ${functionId}.`);
-    }
-    /**
-     * Get function pods
-     *
-     * @param projectId - Project Id
-     * @param functionId - Function Id
-     */
-    // TODO: map the response object
-    async pods(projectId, functionId) {
-        return this.callGet(formatServiceUrl(API_PROJECT_FUNCTION_POD_URL, { url: this.config.url, projectId, functionId }, this.config.insecure), `Failed to ged function pods for ${projectId}, functionId ${functionId}.`);
-    }
-}

package/services/MapService.d.ts

@@ -1,108 +0,0 @@
-import { IBaseService, IRocosSDKConfig, Map, RocosError } from '../models';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-/**
- * Integrations to retrieve data from the linked project in DroneDeploy
- */
-export declare class MapService extends BaseServiceAbstract implements IBaseService {
-    constructor(config: IRocosSDKConfig);
-    getStatus(): boolean;
-    protected getError(e: Error): RocosError;
-    /**
-     * List maps from the cloud
-     *
-     * @param projectId Project ID
-     * @returns All maps in the cloud
-     */
-    list(projectId: string): Promise<Map[]>;
-    /**
-     * List maps from the robot and the cloud
-     *
-     * @param projectId Project ID
-     * @param callsign Robot callsign
-     * @returns All maps in the cloud
-     */
-    list(projectId: string, callsign: string): Promise<Map[]>;
-    /** List maps to be deployed to a callsign
-     *
-     * @param projectId
-     * @param callsign
-     */
-    listDeployedMaps(projectId: string, callsign: string): Promise<Map[]>;
-    /**
-     * Creates a new map by merging two existing maps
-     * @param projectId Project ID
-     * @param maps Array of two map IDs to merge
-     * @param options Options to create the new map
-     */
-    merge(projectId: string, maps: [string, string], options: {
-        name: string;
-        description?: string;
-        callsign: string;
-    }): Promise<void>;
-    /** Returns a map in its canonical form
-     *
-     * @param projectId Project ID
-     * @param mapId Map ID
-     */
-    get(projectId: string, mapId: string): Promise<Map>;
-    /**
-     * Updates a maps metadata
-     * @param projectId Project ID
-     * @param mapId Map ID
-     * @param options New metadata
-     */
-    update(projectId: string, mapId: string, options: {
-        description?: string;
-        callsign?: string;
-    }): Promise<void>;
-    /**
-     * Begins uploading a map from the agent
-     *
-     * @param projectId Project ID
-     * @param mapId Map ID
-     * @param callsign Robot callsign
-     * @param hash Map hash
-     */
-    sendToCloud(projectId: string, mapId: string, callsign: string, hash: string): Promise<void>;
-    /**
-     * Deletes a map from the cloud and all agents
-     * @param projectId
-     * @param mapId
-     */
-    delete(projectId: string, mapId: string): Promise<void>;
-    /**
-     * Deletes a map from a single agent.
-     *
-     * If the callsign does not have the map deployed, any local copy of the map will be deleted.
-     *
-     * @param projectId
-     * @param mapId
-     * @param callsign
-     * @param hash
-     */
-    delete(projectId: string, mapId: string, callsign: string, hash: string): Promise<void>;
-    /**
-     * Makes a copy of an uploaded map
-     *
-     * @param projectId Project ID
-     * @param mapId Map ID
-     * @param options Options to create the new map
-     */
-    copy(projectId: string, mapId: string, options: {
-        description?: string;
-    }): Promise<void>;
-    /** Deploy a map from the cloud to a robot
-     *
-     * @param projectId Project ID
-     * @param mapId Map ID
-     * @param callsign Robot callsign
-     */
-    deploy(projectId: string, mapId: string, callsign: string): Promise<void>;
-    /** Get a GeoJSON representation of a map
-     *
-     * @param projectId Project ID
-     * @param mapId Map ID
-     * @param frameId Frame ID (optional)
-     */
-    getGeoJSON(projectId: string, mapId: string, frameId?: string): Promise<unknown>;
-}