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

package/services/AuthService.d.ts

@@ -1,24 +1,23 @@
-import { IBaseService, IRocosSDKConfig, RocosError, Token } from '../models';
+import { RocosError } from '../models/RocosError';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { ISignupParams } from '../models/ISignupParams';
+import { Token } from '../models/Token';
 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
+     * @param expiresIn - Token expiry time
      */
-    setToken(value: string | Token): void;
+    setToken(value: string, expiresIn: number): void;
     /**
-     * @deprecated `expiresIn` is now derived from the token. Use `setToken(value: string | Token)` instead
-     */
-    setToken(value: string | Token, expiresIn: number): void;
-    /**
-     * Clear token
+     * Cleat auto token
      */
     clearToken(): void;
     /**
@@ -26,68 +25,37 @@ export declare class AuthService extends BaseServiceAbstract implements IBaseSer
      */
     getAppToken(): Promise<Token>;
     /**
-     * Get new auth token for a user
-     * @desc This only works for user auth tokens, not appId auth tokens
+     * Get the authentication token for logged in username and password
      */
-    getNewUserToken(): Promise<Token>;
+    getUserToken(): Promise<Token>;
     /**
-     * Get new auth token for a user.
-     *
-     * Uses the OTP flow to exchange an external token for a user token.
-     *
+     * Get new auth token for a user
      * @desc This only works for user auth tokens, not appId auth tokens
      */
-    private getNewUserTokenFromExternalToken;
+    getNewUserToken(): Promise<Token>;
     /**
      * 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.
+     * Login with email and password.
      *
-     * 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
+     * @deprecated SDK can only be configured with appId and appKey or an existing token
+     * @param email - Email address
+     * @param password - Password
+     * @param invitationCode - Invitation Code (Optional)
      */
-    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;
+    login(email: string, password: string, invitationCode?: string): Promise<any>;
     /**
-     * Stop the token refresh checker
-     * @see startTokenRefreshChecker
+     * Sign up
+     * @deprecated SDK can only be configured with appId and appKey or an existing token
+     * @param params = Signup payload {@link ISignupParams}
      */
-    stopTokenRefreshChecker(): void;
-    /** Check if the token refresh checker is running
-     *
-     * @see startTokenRefreshChecker
-     * @see stopTokenRefreshChecker
-     * @returns true if the token refresh checker is running
+    signup(params: ISignupParams): Promise<any>;
+    /**
+     * Reset users password.
+     * @deprecated SDK can only be configured with appId and appKey or an existing token
+     * @param model - Reset payload
      */
-    isTokenRefreshCheckerRunning(): boolean;
-    /** Checks if the token is valid for use with the API */
-    isTokenValid(token: Token): boolean;
-    private isTokenIssuedByApp;
+    resetPassword(model: any): Promise<any>;
 }

package/services/AuthService.js

@@ -1,48 +1,39 @@
-import { API_APPLICATION_AUTH_URL, API_OTP_AUTH_URL, API_OTP_URL, API_USER_TOKEN_URL } from '../constants/api';
-import { RocosError, Token, errorCodes } from '../models';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-import { RocosLogger } from '../logger/RocosLogger';
-import { RocosStore } from '../store/RocosStore';
-import { formatServiceUrl } from '../helpers/formatServiceUrl';
-import { issuer } from '../constants/auth';
-export class AuthService extends BaseServiceAbstract {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const api_1 = require("../constants/api");
+const RocosError_1 = require("../models/RocosError");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const RocosStore_1 = require("../store/RocosStore");
+const Token_1 = require("../models/Token");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class AuthService extends BaseServiceAbstract_1.BaseServiceAbstract {
     constructor(config) {
         super(config);
         this.config = config;
         this.config = config;
-        this.logger = RocosLogger.getInstance(`AuthService(${this.config.url})`);
-        if (this.config.token) {
-            this.setToken(this.config.token);
-        }
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`AuthService(${this.config.url})`);
     }
     getStatus() {
         return true;
     }
-    teardown() {
-        if (this.isTokenRefreshCheckerRunning()) {
-            this.logger.debug('Stopping token refresh checker');
-            this.stopTokenRefreshChecker();
-        }
-    }
     getError(e) {
-        return new RocosError(e, errorCodes.AUTH_ERROR, e?.statusCode);
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.AUTH_ERROR, e === null || e === void 0 ? void 0 : e.statusCode);
     }
+    /**
+     * Set the Auth token
+     * @param value - Token value
+     * @param expiresIn - Token expiry time
+     */
     setToken(value, expiresIn) {
-        if (expiresIn !== undefined) {
-            this.logger.warn('setToken(value, expiresIn) is deprecated. Use setToken(value) instead');
-        }
-        if (typeof value === 'string') {
-            this.token = new Token(value);
-        }
-        else {
-            this.token = value;
-        }
+        this.token = new Token_1.Token({ value, expiresIn });
         this.config.token = this.token.value;
         // output a message for token change
-        RocosStore.getChangeSubject().next({ type: 'token', url: this.config.url, data: this.token.value });
+        RocosStore_1.RocosStore.getChangeSubject().next({ type: 'token', url: this.config.url, data: this.token.value });
     }
     /**
-     * Clear token
+     * Cleat auto token
      */
     clearToken() {
         this.token = undefined;
@@ -53,183 +44,111 @@ export class AuthService extends BaseServiceAbstract {
      */
     async getAppToken() {
         if (!('appId' in this.config) || !this.config.appId || !('appKey' in this.config) || !this.config.appKey) {
-            throw new RocosError('Can not get app token, missing appId and appKey', errorCodes.AUTH_ERROR);
+            throw new RocosError_1.RocosError('Can not get app token, missing appId and appKey', RocosError_1.errorCodes.AUTH_ERROR);
         }
-        const res = await this.callPost(formatServiceUrl(API_APPLICATION_AUTH_URL, { url: this.config.url }, this.config.insecure), {
+        const res = await this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_APPLICATION_AUTH_URL, { url: this.config.url }, this.config.insecure), {
             applicationId: this.config.appId,
             secret: this.config.appKey,
         }, 'Failed to get users auth token.', { public: true });
-        return new Token(res.token);
+        return new Token_1.Token({ value: res.token, expiresIn: res.expiresIn });
     }
     /**
-     * Get new auth token for a user
-     * @desc This only works for user auth tokens, not appId auth tokens
+     * Get the authentication token for logged in username and password
      */
-    async getNewUserToken() {
-        if (!('token' in this.config) || !this.config.token) {
-            throw new RocosError('Can not get new app token, missing token', errorCodes.AUTH_ERROR);
+    async getUserToken() {
+        if (!('email' in this.config) || !this.config.email || !('password' in this.config) || !this.config.password) {
+            throw new RocosError_1.RocosError('Can not get user token, missing email and password', RocosError_1.errorCodes.AUTH_ERROR);
         }
-        const token = new Token(this.config.token, this.config.refreshToken);
-        if (token?.isExpired()) {
-            throw new RocosError('Token expired', errorCodes.AUTH_ERROR);
+        try {
+            // TODO: there is no token expiry returned on user token
+            const { token, expiresIn } = await this.login(this.config.email, this.config.password, this.config.invitationCode);
+            return new Token_1.Token({ value: token, expiresIn });
         }
-        if (!this.isTokenIssuedByApp(token)) {
-            this.logger.info('Token is not issued by app. Getting new token from DD token.');
-            return this.getNewUserTokenFromExternalToken();
+        catch (e) {
+            const message = 'Failed to get users auth token.';
+            this.logger.error(message, e);
+            e.message = message;
+            throw new RocosError_1.RocosError(e, RocosError_1.errorCodes.AUTH_ERROR);
         }
-        return this.refreshToken(token);
     }
     /**
-     * Get new auth token for a user.
-     *
-     * Uses the OTP flow to exchange an external token for a user token.
-     *
+     * Get new auth token for a user
      * @desc This only works for user auth tokens, not appId auth tokens
      */
-    async getNewUserTokenFromExternalToken() {
-        if (!('token' in this.config) || !this.config.token) {
-            throw new RocosError('Can not get new token, missing token', errorCodes.AUTH_ERROR);
+    async getNewUserToken() {
+        if (!('token' in this.config)) {
+            throw new RocosError_1.RocosError('Can not get new app token, missing token', RocosError_1.errorCodes.AUTH_ERROR);
         }
-        const ddToken = new Token(this.config.token);
-        const { otp } = await this.callPost(formatServiceUrl(API_OTP_URL, { url: this.config.url }, this.config.insecure), undefined, 'Failed to get one time password.', { public: true, headers: { Authorization: ddToken.bearer } });
-        const { token, refreshToken } = await this.callPost(formatServiceUrl(API_OTP_AUTH_URL, { url: this.config.url }, this.config.insecure), { otp }, 'Failed to get users auth token.', { public: true });
-        return new Token(token, refreshToken);
+        const res = await this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_USER_TOKEN_URL, { url: this.config.url }, this.config.insecure), 'Failed to get users auth token.', undefined, { public: true, headers: { Authorization: `Bearer ${this.config.token}` } });
+        return new Token_1.Token({ value: res.token });
     }
     /**
      * 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.
      */
     async getToken() {
-        if (this.token && this.isTokenValid(this.token)) {
-            if (this.token.isExpiredIn(15, 'minutes')) {
-                this.logger.info('Token expires within 15 minutes. Refreshing.');
-                const newToken = await this.refreshToken();
-                this.setToken(newToken);
-                return newToken;
-            }
+        if (this.token && !this.token.isExpired()) {
             return this.token;
         }
-        let token;
         try {
             if ('appId' in this.config && 'appKey' in this.config) {
-                token = await this.getAppToken();
+                this.token = await this.getAppToken();
+            }
+            else if ('email' in this.config && 'password' in this.config) {
+                this.token = await this.getUserToken();
             }
             else if ('token' in this.config) {
-                token = await this.getNewUserToken();
+                this.token = await this.getNewUserToken();
+            }
+            else {
+                throw new Error('Config invalid');
             }
+            this.config.token = this.token.value;
+            // output a message for token change
+            RocosStore_1.RocosStore.getChangeSubject().next({ type: 'token', url: this.config.url, data: this.token.value });
+            return this.token;
         }
         catch (e) {
             const message = 'Failed to get auth token.';
             this.logger.error(message, e);
-            if (e instanceof Error) {
-                e.message = message;
-                throw new RocosError(e, errorCodes.AUTH_ERROR);
-            }
-            else {
-                throw new RocosError(message, errorCodes.AUTH_ERROR);
-            }
-        }
-        if (!token) {
-            const message = 'Failed to get auth token. Config invalid.';
-            this.logger.error(message);
-            throw new RocosError(message, errorCodes.AUTH_ERROR);
+            e.message = message;
+            throw new RocosError_1.RocosError(e, RocosError_1.errorCodes.AUTH_ERROR);
         }
-        this.setToken(token);
-        return token;
     }
     /**
-     * Refresh the authentication token
-     *
-     * This only works for user auth tokens, not appId auth tokens.
+     * Login with email and password.
      *
-     * 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.
+     * @deprecated SDK can only be configured with appId and appKey or an existing token
+     * @param email - Email address
+     * @param password - Password
+     * @param invitationCode - Invitation Code (Optional)
      */
-    async refreshToken(token) {
-        const tokenToRefresh = token ?? this.token;
-        if (!tokenToRefresh) {
-            throw new RocosError('No token to refresh', errorCodes.AUTH_ERROR);
-        }
-        const res = await this.callGet(formatServiceUrl(API_USER_TOKEN_URL, { url: this.config.url }, this.config.insecure), 'Failed to get users auth token.', undefined, { public: true, headers: { Authorization: tokenToRefresh.bearer } });
-        return new Token(res.token, res.refreshToken);
-    }
-    /** 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
-     */
-    async refreshTokenIfExpired(minutes) {
-        if (this.token?.isExpiredIn(minutes, 'minutes')) {
-            this.logger.info('Token expires in 15 minutes. Refreshing.');
-            const newToken = await this.refreshToken();
-            this.setToken(newToken);
-        }
-    }
-    /** 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() {
-        const maxInterval = 1000 * 60 * 10; // 10 minutes
-        const minInterval = 1000 * 60; // 1 minute
-        const threshold = 1000 * 60 * 15; // 15 minutes
-        if (this.isTokenRefreshCheckerRunning())
-            return;
-        if (!this.token)
-            throw new RocosError('No token to refresh', errorCodes.AUTH_ERROR);
-        if (!this.isTokenValid(this.token))
-            throw new RocosError('Token is not valid', errorCodes.AUTH_ERROR);
-        const loop = () => {
-            this.logger.debug('Checking scheduled token refresh');
-            this.refreshTokenIfExpired(15)
-                .catch((e) => {
-                this.logger.error('Failed to refresh token', e);
-            })
-                .finally(() => {
-                if (!this.token?.expires)
-                    return;
-                // schedule next check
-                const timeTillThreshold = this.token.expires.getTime() - Date.now() - threshold;
-                const interval = Math.max(minInterval, Math.min(maxInterval, timeTillThreshold));
-                this.tokenRefreshTimeoutId = setTimeout(() => loop(), interval);
-            });
-        };
-        loop();
+    // TODO: map the response object
+    async login(email, password, invitationCode) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_USER_AUTH_URL, { url: this.config.url }, this.config.insecure), {
+            email,
+            password,
+            invitationCode,
+        }, 'Failed to login user.', { public: true });
     }
     /**
-     * Stop the token refresh checker
-     * @see startTokenRefreshChecker
+     * Sign up
+     * @deprecated SDK can only be configured with appId and appKey or an existing token
+     * @param params = Signup payload {@link ISignupParams}
      */
-    stopTokenRefreshChecker() {
-        clearTimeout(this.tokenRefreshTimeoutId);
-        this.tokenRefreshTimeoutId = undefined;
+    // TODO: map the response object
+    async signup(params) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_USER_URL, { url: this.config.url }, this.config.insecure), params, 'Failed to sign up user.', { public: true });
     }
-    /** Check if the token refresh checker is running
-     *
-     * @see startTokenRefreshChecker
-     * @see stopTokenRefreshChecker
-     * @returns true if the token refresh checker is running
+    /**
+     * Reset users password.
+     * @deprecated SDK can only be configured with appId and appKey or an existing token
+     * @param model - Reset payload
      */
-    isTokenRefreshCheckerRunning() {
-        return this.tokenRefreshTimeoutId !== undefined;
-    }
-    /** Checks if the token is valid for use with the API */
-    isTokenValid(token) {
-        return !token.isExpired() && this.isTokenIssuedByApp(token);
-    }
-    isTokenIssuedByApp(token) {
-        return token.issuer === issuer;
+    // TODO: map the request model
+    // TODO: map the response object
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async resetPassword(model) {
+        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_USER_PASSWORD_RESET_URL, { url: this.config.url }, this.config.insecure), model, 'Failed to reset password.', { public: true });
     }
 }
+exports.AuthService = AuthService;

package/services/BaseServiceAbstract.d.ts

@@ -1,7 +1,9 @@
-import { IRocosSDKConfig, RocosError } from '../models';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
 import { Logger } from 'loglevel';
-type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
-type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
+import { RocosError } from '../models/RocosError';
+declare type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
+declare type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
+declare type Payload = unknown;
 interface RequestConfig {
     /**
      * Additional headers to send with the request.
@@ -19,18 +21,18 @@ interface RequestConfig {
 export declare abstract class BaseServiceAbstract {
     protected config: IRocosSDKConfig;
     protected logger: Logger;
-    protected constructor(config: IRocosSDKConfig);
+    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: {
+    protected callPost<T = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<T>;
+    protected callPut<T = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<T>;
+    protected callDelete<T = unknown>(url: string, errorMessage: string, payload?: unknown): Promise<T>;
+    protected callGet<T = unknown>(url: string, errorMessage: string, params?: QueryParams, config?: RequestConfig): Promise<T>;
+    protected call<T = unknown>(url: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE', options: {
         errorMessage: string;
         config?: RequestConfig;
-        payload?: Payload;
+        payload?: unknown;
         params?: QueryParams;
-    }): Promise<Response>;
+    }): Promise<T>;
     private fetchOrThrow;
 }
 export {};

package/services/BaseServiceAbstract.js

@@ -1,5 +1,8 @@
-import { RocosError } from '../models';
-import { RocosStore } from '../store/RocosStore';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseServiceAbstract = void 0;
+const RocosError_1 = require("../models/RocosError");
+const RocosStore_1 = require("../store/RocosStore");
 class HttpError extends Error {
     constructor(response) {
         super(response.statusText);
@@ -7,7 +10,7 @@ class HttpError extends Error {
         this.name = 'HttpError';
     }
 }
-export class BaseServiceAbstract {
+class BaseServiceAbstract {
     constructor(config) {
         this.config = config;
     }
@@ -24,25 +27,23 @@ export class BaseServiceAbstract {
         return this.call(url, 'GET', { errorMessage, params, config });
     }
     async call(url, method, options) {
+        var _a;
         const { errorMessage, config, payload, params } = options;
         try {
             // change all params to string
-            const stringParams = Object.entries(params ?? {}).reduce((acc, [key, value]) => {
+            const stringParams = Object.entries(params || {}).reduce((acc, [key, value]) => {
                 acc[key] = value.toString();
                 return acc;
             }, {});
             const formattedUrl = params ? `${url}?${new URLSearchParams(stringParams)}` : url;
             const defaultHeaders = {};
-            if (!config?.public) {
-                const token = await RocosStore.getSDKInstance(this.config).getAuthService().getToken();
-                defaultHeaders.Authorization = token.bearer;
+            if (!(config === null || config === void 0 ? void 0 : config.public)) {
+                const token = await RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService().getToken();
+                defaultHeaders.Authorization = `Bearer ${token.value}`;
             }
             const requestConfig = {
                 method,
-                headers: {
-                    ...defaultHeaders,
-                    ...config?.headers,
-                },
+                headers: Object.assign(Object.assign({}, defaultHeaders), config === null || config === void 0 ? void 0 : config.headers),
             };
             // must check if FormData exists for node support
             if (typeof FormData !== 'undefined' && payload instanceof FormData) {
@@ -50,19 +51,19 @@ export class BaseServiceAbstract {
             }
             else if (payload) {
                 requestConfig.body = JSON.stringify(payload);
-                requestConfig.headers = { ...requestConfig.headers, 'Content-Type': 'application/json' };
+                requestConfig.headers = Object.assign(Object.assign({}, requestConfig.headers), { 'Content-Type': 'application/json' });
             }
-            return this.fetchOrThrow(formattedUrl, requestConfig, config?.responseType);
+            return this.fetchOrThrow(formattedUrl, requestConfig, config === null || config === void 0 ? void 0 : config.responseType);
         }
         catch (e) {
             const message = errorMessage;
             this.logger.error(message, e);
-            let httpError = new RocosError(message);
+            let httpError = new RocosError_1.RocosError(message);
             if (e instanceof HttpError) {
                 httpError = this.getError(e);
-                httpError.statusCode = e?.response?.status;
+                httpError.statusCode = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status;
             }
-            RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
+            RocosStore_1.RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
             throw httpError;
         }
     }
@@ -86,7 +87,7 @@ export class BaseServiceAbstract {
             case 'json':
             default: {
                 const textRes = await res.text();
-                if (!textRes?.trim())
+                if (!(textRes === null || textRes === void 0 ? void 0 : textRes.trim()))
                     return undefined;
                 try {
                     return JSON.parse(textRes);
@@ -99,3 +100,4 @@ export class BaseServiceAbstract {
         }
     }
 }
+exports.BaseServiceAbstract = BaseServiceAbstract;

package/services/CallerService.d.ts

@@ -1,10 +1,22 @@
-import { ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IRocosSDKConfig, IStreamConfig } from '../models';
-import { Observable } from 'rxjs';
-import { BaseStreamService } from './BaseStreamService';
-export declare class CallerService extends BaseStreamService<ICallerStream> {
+import { ICallerInvokeParams, ICallerParams } from '../models/params/ICallerParams';
+import { Observable, Subject } from 'rxjs';
+import { IBaseService } from '../models/IBaseService';
+import { ICallerStream } from '../models/stream/ICallerStream';
+import { IRocosCallerMessage } from '../models/message/IRocosCallerMessage';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { IStreamConfig } from '../models/IStreamConfig';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
+export declare class CallerService implements IBaseService, ISubscriberStatus {
+    private config;
+    private logger;
+    private status;
+    status$: Subject<SubscriberStatusEnum>;
     constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
     invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
     cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
-    protected createStream(): Promise<ICallerStream>;
+    private createStream;
+    private initStream;
     protected getStream(config: IStreamConfig): ICallerStream;
 }