@dronedeploy/rocos-js-sdk 3.0.1-alpha → 3.0.1-alpha.11

package/esm/services/AssetStorageService.d.ts

@@ -0,0 +1,137 @@
+import { AssetItemModel, AssetItemWithObservationsModel, AssetSyncDefinitionsModel, AssetSyncIntegrationModel, AssetSyncIntegrationProviderModel, CreateAssetSyncIntegrationModel, IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+export declare class AssetStorageService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Create a new project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     * @param file - File payload
+     */
+    create(projectId: string, filePath: string, file: File): Promise<AssetItemModel>;
+    /**
+     * Update a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     * @param file - File payload
+     */
+    update(projectId: string, filePath: string, file: File): Promise<AssetItemModel>;
+    /**
+     * Delete a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    delete(projectId: string, filePath: string): Promise<unknown>;
+    list(projectId: string): Promise<AssetItemModel[]>;
+    list(projectId: string, filePath: string): Promise<unknown>;
+    /**
+     * Get a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    getAsset(projectId: string, filePath: string): Promise<Blob>;
+    /**
+     * List assets for a robot
+     *
+     * @param projectId
+     * @param callsign
+     * @param parent
+     * @param signedURL
+     */
+    listRobotAssets(projectId: string, callsign: string, parent?: string, signedURL?: boolean): Promise<AssetItemModel[]>;
+    /**
+     * List assets for a flow
+     *
+     * @param projectId
+     * @param flowId
+     * @param flowInstance
+     * @param parent
+     * @param signedURL
+     */
+    listFlowAssets(projectId: string, flowId: string, flowInstance: string, parent?: string, signedURL?: boolean): Promise<AssetItemModel[]>;
+    /**
+     * List assets for a mission
+     *
+     * @param projectId
+     * @param assetIdList
+     */
+    listMissionAssets(projectId: string, assetIdList: string[]): Promise<AssetItemModel[]>;
+    /**
+     * Get a single asset for a mission
+     *
+     * @param projectId
+     * @param assetId
+     */
+    getMissionAsset(projectId: string, assetId: string): Promise<AssetItemModel>;
+    /**
+     * Lists mapped assets
+     *
+     * @param projectId
+     * @param start Start date for the query (optional)
+     * @param end End date for the query (optional)
+     * @param includeObservations If observations should be included in the response (optional)
+     */
+    listMappedAssets(projectId: string, start?: Date, end?: Date, includeObservations?: boolean): Promise<AssetItemWithObservationsModel[]>;
+    /**
+     * Set Robot Sync Definitions
+     * @param projectId
+     * @param callsign
+     * @param definition
+     * @param syncNow - Sync configured paths immediately
+     */
+    setRobotSyncDefinitions(projectId: string, callsign: string, definition: AssetSyncDefinitionsModel, syncNow?: boolean): Promise<AssetSyncDefinitionsModel>;
+    /**
+     * Get Robot Sync Definitions
+     * @param projectId
+     * @param callsign
+     */
+    getRobotSyncDefinitions(projectId: string, callsign: string): Promise<AssetSyncDefinitionsModel>;
+    /**
+     * Set Profile Sync Definitions
+     * @param projectId
+     * @param profileId
+     * @param definition
+     */
+    setProfileSyncDefinitions(projectId: string, profileId: string, definition: AssetSyncDefinitionsModel): Promise<AssetSyncDefinitionsModel>;
+    /**
+     * Get Profile Sync Definitions
+     * @param projectId
+     * @param profileId
+     */
+    getProfileSyncDefinition(projectId: string, profileId: string): Promise<AssetSyncDefinitionsModel>;
+    /**
+     * Get Sync Integration Providers
+     * @param projectId
+     */
+    getSyncIntegrationProviders(projectId: string): Promise<AssetSyncIntegrationProviderModel[]>;
+    /**
+     * Get Sync Integrations by Project
+     * @param projectId
+     */
+    getSyncIntegrations(projectId: string): Promise<AssetSyncIntegrationModel[]>;
+    /**
+     * Create a new Sync Integration
+     * @param projectId
+     * @param integration
+     */
+    createSyncIntegration(projectId: string, integration: CreateAssetSyncIntegrationModel): Promise<AssetSyncIntegrationModel>;
+    /**
+     * Update a Sync Integration
+     * @param projectId
+     * @param integrationId
+     * @param integration
+     */
+    updateSyncIntegration(projectId: string, integrationId: string, integration: CreateAssetSyncIntegrationModel): Promise<AssetSyncIntegrationModel>;
+    /**
+     * Delete a Sync Integration
+     * @param projectId
+     * @param integrationId
+     */
+    deleteSyncIntegration(projectId: string, integrationId: string): Promise<void>;
+}

package/esm/services/AssetStorageService.js

@@ -0,0 +1,223 @@
+import { API_PROJECT_ASSET_INTEGRATIONS_PATH_URL, API_PROJECT_ASSET_INTEGRATION_PATH_URL, API_PROJECT_ASSET_INTEGRATION_PROVIDERS_PATH_URL, API_PROJECT_ASSET_PATH_URL, API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, API_PROJECT_ASSET_URL, API_PROJECT_FLOW_ASSET_PATH_URL, API_PROJECT_MAPPED_ASSETS_PATH_URL, API_PROJECT_MISSION_ASSETS_PATH_URL, API_PROJECT_MISSION_ASSET_PATH_URL, API_PROJECT_ROBOT_ASSET_PATH_URL, } from '../constants/api';
+import { RocosError, errorCodes, } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class AssetStorageService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`AssetStorageService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.ASSET_STORAGE_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a new project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     * @param file - File payload
+     */
+    async create(projectId, filePath, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.callPut(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), formData, `Failed to create asset for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Update a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     * @param file - File payload
+     */
+    async update(projectId, filePath, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.callPost(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), formData, `Failed to update asset for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Delete a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    // TODO: map the response object
+    async delete(projectId, filePath) {
+        return this.callDelete(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), `Failed to delete asset for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Lost assets for a project or project file path
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    async list(projectId, filePath) {
+        let url = '';
+        if (filePath) {
+            url = formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure);
+        }
+        else {
+            url = formatServiceUrl(API_PROJECT_ASSET_URL, { url: this.config.url, projectId }, this.config.insecure);
+        }
+        return this.callGet(url, `Failed to get asset list for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Get a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    async getAsset(projectId, filePath) {
+        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), `Failed to get asset for ${projectId}, filePath ${filePath}.`, undefined, {
+            responseType: 'blob',
+        });
+    }
+    /**
+     * List assets for a robot
+     *
+     * @param projectId
+     * @param callsign
+     * @param parent
+     * @param signedURL
+     */
+    async listRobotAssets(projectId, callsign, parent = '/', signedURL = false) {
+        return this.callGet(formatServiceUrl(API_PROJECT_ROBOT_ASSET_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get asset for ${projectId}, callsign ${callsign}.`, { parent, signedURL });
+    }
+    /**
+     * List assets for a flow
+     *
+     * @param projectId
+     * @param flowId
+     * @param flowInstance
+     * @param parent
+     * @param signedURL
+     */
+    async listFlowAssets(projectId, flowId, flowInstance, parent = '/', signedURL = false) {
+        return this.callGet(formatServiceUrl(API_PROJECT_FLOW_ASSET_PATH_URL, { url: this.config.url, projectId, flowId, flowInstance }, this.config.insecure), `Failed to get asset for ${projectId}, flow ${flowId}, flow instance ${flowInstance}.`, { parent, signedURL });
+    }
+    /**
+     * List assets for a mission
+     *
+     * @param projectId
+     * @param assetIdList
+     */
+    async listMissionAssets(projectId, assetIdList) {
+        const searchParams = new URLSearchParams();
+        assetIdList.forEach((assetId) => searchParams.append('assetID', assetId));
+        return this.callGet(formatServiceUrl(API_PROJECT_MISSION_ASSETS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset for ${projectId}, assetIdList ${assetIdList}.`, searchParams);
+    }
+    /**
+     * Get a single asset for a mission
+     *
+     * @param projectId
+     * @param assetId
+     */
+    async getMissionAsset(projectId, assetId) {
+        return this.callGet(formatServiceUrl(API_PROJECT_MISSION_ASSET_PATH_URL, { url: this.config.url, projectId, assetId }, this.config.insecure), `Failed to get asset for ${projectId}, dataUUID ${assetId}.`, undefined);
+    }
+    /**
+     * Lists mapped assets
+     *
+     * @param projectId
+     * @param start Start date for the query (optional)
+     * @param end End date for the query (optional)
+     * @param includeObservations If observations should be included in the response (optional)
+     */
+    async listMappedAssets(projectId, start, end, includeObservations) {
+        return this.callGet(formatServiceUrl(API_PROJECT_MAPPED_ASSETS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to list mapped assets for ${projectId}.`, {
+            start: start?.toISOString() ?? '',
+            end: end?.toISOString() ?? '',
+            includeObservations: includeObservations ? 'true' : 'false',
+        });
+    }
+    /**
+     * Set Robot Sync Definitions
+     * @param projectId
+     * @param callsign
+     * @param definition
+     * @param syncNow - Sync configured paths immediately
+     */
+    setRobotSyncDefinitions(projectId, callsign, definition, syncNow = false) {
+        const url = formatServiceUrl(API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure);
+        const httpOptions = {
+            headers: {
+                'content-type': 'application/json',
+            },
+        };
+        return this.callPost(url, definition, `Failed to update asset for ${projectId}, callsign ${callsign}.`, httpOptions, {
+            syncNow,
+        });
+    }
+    /**
+     * Get Robot Sync Definitions
+     * @param projectId
+     * @param callsign
+     */
+    getRobotSyncDefinitions(projectId, callsign) {
+        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get asset for ${projectId}, callsign ${callsign}.`, undefined);
+    }
+    /**
+     * Set Profile Sync Definitions
+     * @param projectId
+     * @param profileId
+     * @param definition
+     */
+    setProfileSyncDefinitions(projectId, profileId, definition) {
+        const httpOptions = {
+            headers: {
+                'content-type': 'application/json',
+            },
+        };
+        return this.callPost(formatServiceUrl(API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), definition, `Failed to update sync-definition for ${projectId}, callsign ${profileId}.`, httpOptions);
+    }
+    /**
+     * Get Profile Sync Definitions
+     * @param projectId
+     * @param profileId
+     */
+    getProfileSyncDefinition(projectId, profileId) {
+        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), `Failed to get sync-definition for ${projectId}, callsign ${profileId}.`, undefined);
+    }
+    /**
+     * Get Sync Integration Providers
+     * @param projectId
+     */
+    getSyncIntegrationProviders(projectId) {
+        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_INTEGRATION_PROVIDERS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset sync integration providers for ${projectId}.`);
+    }
+    /**
+     * Get Sync Integrations by Project
+     * @param projectId
+     */
+    getSyncIntegrations(projectId) {
+        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_INTEGRATIONS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset sync integrations for ${projectId}.`);
+    }
+    /**
+     * Create a new Sync Integration
+     * @param projectId
+     * @param integration
+     */
+    createSyncIntegration(projectId, integration) {
+        return this.callPost(formatServiceUrl(API_PROJECT_ASSET_INTEGRATIONS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), integration, `Failed to create asset sync integration for ${projectId}.`);
+    }
+    /**
+     * Update a Sync Integration
+     * @param projectId
+     * @param integrationId
+     * @param integration
+     */
+    updateSyncIntegration(projectId, integrationId, integration) {
+        return this.callPut(formatServiceUrl(API_PROJECT_ASSET_INTEGRATION_PATH_URL, { url: this.config.url, projectId, integrationId }, this.config.insecure), integration, `Failed to update asset sync integrations for ${projectId}.`);
+    }
+    /**
+     * Delete a Sync Integration
+     * @param projectId
+     * @param integrationId
+     */
+    deleteSyncIntegration(projectId, integrationId) {
+        return this.callDelete(formatServiceUrl(API_PROJECT_ASSET_INTEGRATION_PATH_URL, { url: this.config.url, projectId, integrationId }, this.config.insecure), `Failed to delete asset sync integrations for ${projectId}.`);
+    }
+}

package/esm/services/AuthService.d.ts

@@ -0,0 +1,93 @@
+import { IBaseService, IRocosSDKConfig, RocosError, Token } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+export declare class AuthService extends BaseServiceAbstract implements IBaseService {
+    protected config: IRocosSDKConfig;
+    private token?;
+    private tokenRefreshTimeoutId?;
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    teardown(): void;
+    protected getError(e: RocosError): RocosError;
+    /**
+     * Set the Auth token
+     * @param value - Token value
+     */
+    setToken(value: string | Token): void;
+    /**
+     * @deprecated `expiresIn` is now derived from the token. Use `setToken(value: string | Token)` instead
+     */
+    setToken(value: string | Token, expiresIn: number): void;
+    /**
+     * Clear token
+     */
+    clearToken(): void;
+    /**
+     * Get the authentication token for application Id and application Key.
+     */
+    getAppToken(): Promise<Token>;
+    /**
+     * Get new auth token for a user
+     * @desc This only works for user auth tokens, not appId auth tokens
+     */
+    getNewUserToken(): Promise<Token>;
+    /**
+     * Get new auth token for a user.
+     *
+     * Uses the OTP flow to exchange an external token for a user token.
+     *
+     * @desc This only works for user auth tokens, not appId auth tokens
+     */
+    private getNewUserTokenFromExternalToken;
+    /**
+     * Get the authentication token
+     *
+     * This will return the current token if it is not expired, otherwise it will get a new token based on your config.
+     */
+    getToken(): Promise<Token>;
+    /**
+     * Refresh the authentication token
+     *
+     * This only works for user auth tokens, not appId auth tokens.
+     *
+     * The new token is not automatically set as the current token. Use `setToken` to set the new token.
+     *
+     * @see setToken
+     * @param token the token to refresh. If not provided, the current token will be used.
+     */
+    refreshToken(token?: Token): Promise<Token>;
+    /** Refresh the token if it is expired or will expire in the next `minutes` minutes
+     *
+     * This only works for user auth tokens, not appId auth tokens.
+     *
+     * If you want to refresh the token regardless of the expiry time, use `refreshToken`.
+     *
+     * @param minutes the number of minutes before the token expires to refresh the token
+     * @see refreshToken
+     */
+    refreshTokenIfExpired(minutes: number): Promise<void>;
+    /** Start a 5-minute loop to check if the token needs to be refreshed
+     *
+     * This is useful when you are using GRPC services (i.e. telemetry) which does not automatically refresh the token.
+     * It is not required when using REST services as the token is refreshed automatically.
+     *
+     * The loop will stop when `stopTokenRefreshChecker` is called.
+     *
+     * @see stopTokenRefreshChecker
+     */
+    startTokenRefreshChecker(): void;
+    /**
+     * Stop the token refresh checker
+     * @see startTokenRefreshChecker
+     */
+    stopTokenRefreshChecker(): void;
+    /** Check if the token refresh checker is running
+     *
+     * @see startTokenRefreshChecker
+     * @see stopTokenRefreshChecker
+     * @returns true if the token refresh checker is running
+     */
+    isTokenRefreshCheckerRunning(): boolean;
+    /** Checks if the token is valid for use with the API */
+    isTokenValid(token: Token): boolean;
+    private isTokenIssuedByApp;
+}

package/esm/services/AuthService.spec.d.ts

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

package/esm/services/BaseServiceAbstract.d.ts

@@ -0,0 +1,36 @@
+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, params?: QueryParams): 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/esm/services/BaseServiceAbstract.js

@@ -0,0 +1,90 @@
+import { RocosError, HttpError } from '../models';
+import { getURLSearchParams } from '../helpers';
+import { RocosStore } from '../store/RocosStore';
+export class BaseServiceAbstract {
+    constructor(config) {
+        this.config = config;
+    }
+    async callPost(url, payload, errorMessage, config, params) {
+        return this.call(url, 'POST', { errorMessage, payload, config, params });
+    }
+    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, payload);
+        }
+        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/esm/services/BaseStreamService.d.ts

@@ -0,0 +1,18 @@
+import { IBaseService, IBaseStream, IRocosSDKConfig, IStreamConfig, SubscriberStatusEnum } from '../models';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { Logger } from 'loglevel';
+import { Subject } from 'rxjs';
+export declare abstract class BaseStreamService<T extends IBaseStream, C extends IStreamConfig = IStreamConfig> implements IBaseService, ISubscriberStatus {
+    protected config: IRocosSDKConfig;
+    protected logger: Logger;
+    protected status: boolean;
+    status$: Subject<SubscriberStatusEnum>;
+    protected constructor(name: string, config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected initStream(stream: T): Promise<void>;
+    protected createStreamFromConfig(identifier: string, config: C): Promise<{
+        stream: T;
+        isNew: boolean;
+    }>;
+    protected abstract getStream(config: C): T;
+}

package/esm/services/BaseStreamService.js

@@ -0,0 +1,49 @@
+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) {
+        if (this.config.insecure)
+            return; // no need to init auth for insecure connections
+        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, config.scope);
+        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 };
+    }
+}