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

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): 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/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,47 @@
+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, 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 };
+    }
+}

package/esm/services/CallerService.d.ts

@@ -0,0 +1,42 @@
+import { ICallerCallParams, ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IRocosCallerMessageResponseAck, IRocosCallerMessageResponseResult, IRocosCallerMessageResponseReturn, 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>;
+    /** Call a service and return the response(s).
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * @see invokeRequest
+     * @see call
+     */
+    callRaw(params: ICallerCallParams): {
+        return$: Observable<IRocosCallerMessageResponseReturn>;
+        result$: Observable<IRocosCallerMessageResponseResult>;
+        ack$: Observable<IRocosCallerMessageResponseAck>;
+    };
+    /** Call a service and return the response(s) as UTF-8 encoded JSON.
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * Equivalent to calling `callRaw` and then parsing the return payload as UTF-8 encoded JSON.
+     *
+     * @see callRaw
+     * @see invokeRequest
+     */
+    call<T = unknown>(params: ICallerCallParams): {
+        return$: Observable<T>;
+        result$: Observable<IRocosCallerMessageResponseResult>;
+        ack$: Observable<IRocosCallerMessageResponseAck>;
+    };
+    protected createStream(): Promise<ICallerStream>;
+    protected getStream(config: IStreamConfig): ICallerStream;
+}

package/esm/services/CallerService.js

@@ -0,0 +1,117 @@
+import { splitRobotTopic } from '../helpers/splitRobotTopic';
+import { ResultStatus, RocosResponseLevel, } from '../models';
+import { Subject, map, mergeMap, take, takeUntil } from 'rxjs';
+import { filter, finalize } from 'rxjs/operators';
+import { getResponses, handleChunkedMessages } from '../helpers/callerMessageHelpers';
+import { BaseStreamService } from './BaseStreamService';
+import { CallerStream } from '../api/streams/caller/CallerStream';
+import { IDENTIFIER_NAME_CALLER } from '../constants/identifier';
+import { v4 } from 'uuid';
+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();
+        }));
+    }
+    /** Call a service and return the response(s).
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * @see invokeRequest
+     * @see call
+     */
+    callRaw(params) {
+        const { component, topic } = splitRobotTopic(params.source);
+        const payloadString = JSON.stringify(params.payload ?? {});
+        const source$ = this.invokeRequest({
+            uid: params.options?.uid ?? v4(),
+            projectId: params.projectId,
+            callsign: params.callsign,
+            subSystem: '',
+            component,
+            topic,
+            responseLevelNumber: RocosResponseLevel.ALL,
+            payload: payloadString,
+            query: params.options?.query,
+        }).pipe(mergeMap(getResponses), handleChunkedMessages());
+        const result$ = source$.pipe(filter((x) => x.result !== undefined), map((x) => x.result), take(1));
+        const resultNotifier$ = result$.pipe(map((x) => {
+            if (x.status !== ResultStatus.COMPLETE_SUCCESS)
+                throw x;
+            return x;
+        }));
+        const return$ = source$.pipe(filter((x) => x.return !== undefined), map((x) => x.return), takeUntil(resultNotifier$));
+        const ack$ = source$.pipe(filter((x) => x.ack !== undefined), map((x) => x.ack), takeUntil(resultNotifier$));
+        return {
+            return$,
+            result$,
+            ack$,
+        };
+    }
+    /** Call a service and return the response(s) as UTF-8 encoded JSON.
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * Equivalent to calling `callRaw` and then parsing the return payload as UTF-8 encoded JSON.
+     *
+     * @see callRaw
+     * @see invokeRequest
+     */
+    call(params) {
+        const stream = this.callRaw(params);
+        return {
+            ...stream,
+            return$: stream.return$.pipe(map((x) => {
+                const decoded = new TextDecoder().decode(x.payload);
+                return JSON.parse(decoded);
+            })),
+        };
+    }
+    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/esm/services/CallerService.spec.d.ts

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

package/esm/services/CallerService.spec.js

@@ -0,0 +1,227 @@
+import { AckStatus, ResultStatus, Stage, UIDVersion, } from '../models';
+import { concatMap, delay, from, of } from 'rxjs';
+import { CallerService } from './CallerService';
+import { TestScheduler } from 'rxjs/testing';
+const makeCallerMessage = (responses) => ({
+    responses: {
+        responses: responses ?? [],
+    },
+});
+const makeCallerChunkedMessage = (responses) => {
+    return responses.map((response, index) => {
+        if ('return' in response) {
+            throw new Error('Cannot create chunked message with return');
+        }
+        const chunk = response;
+        chunk.chunkIndex = index;
+        chunk.chunkCount = responses.length;
+        chunk.header = {
+            created: '0',
+            meta: {},
+        };
+        return {
+            chunks: {
+                chunks: [chunk],
+            },
+        };
+    });
+};
+const uid = {
+    hash: 'hash',
+    version: UIDVersion.HEADER_HASH_RAND,
+};
+const ack = (id) => ({
+    uid,
+    ack: {
+        status: AckStatus.PROGRESS,
+        message: id,
+        stage: Stage.AGENT,
+    },
+});
+const ret = (id) => {
+    const encoder = new TextEncoder();
+    const payload = encoder.encode(JSON.stringify({ id }));
+    return {
+        uid,
+        return: {
+            payload,
+        },
+    };
+};
+const chunkRet = (payload) => {
+    const array = new TextEncoder().encode(payload);
+    return {
+        uid,
+        payload: array,
+        chunkIndex: 0,
+        chunkCount: 1,
+        header: {
+            created: '0',
+            meta: {},
+        },
+    };
+};
+const res = (ok) => ({
+    uid,
+    result: {
+        status: ok ? ResultStatus.COMPLETE_SUCCESS : ResultStatus.FATAL,
+        message: ok ? 'everything is fine' : 'nothing is fine',
+    },
+});
+let testScheduler;
+let service;
+describe('CallerService', () => {
+    beforeEach(() => {
+        service = new CallerService({
+            url: 'http://localhost:8080',
+            token: 'token',
+        });
+        testScheduler = new TestScheduler((actual, expected) => {
+            expect(actual).toEqual(expected);
+        });
+    });
+    describe('callRaw', () => {
+        it('should handle a successful call', () => {
+            // Arrange
+            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
+                return from([
+                    makeCallerMessage([ack('a')]),
+                    makeCallerMessage([ack('b')]),
+                    makeCallerMessage([ack('c'), ret(1)]),
+                    makeCallerMessage([ret(2)]),
+                    makeCallerMessage([ret(3), ret(4)]),
+                    makeCallerMessage([ack('d')]),
+                    makeCallerMessage([ack('e')]),
+                    makeCallerMessage([ack('f')]),
+                    makeCallerMessage([ack('g'), res(true)]),
+                    makeCallerMessage([ack('h')]),
+                ]).pipe(concatMap((item) => of(item).pipe(delay(1))));
+            });
+            testScheduler.run(({ expectObservable }) => {
+                // Act
+                const call = service.call({
+                    callsign: 'callsign',
+                    projectId: 'project',
+                    source: '/test',
+                });
+                // Assert
+                const expectedAckMarbles = '-abc--def|';
+                const expectedRetMarbles = '---ab(cd)|';
+                const expectedResMarbles = '---------(a|)';
+                const expectedAckValues = {
+                    a: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'a' },
+                    b: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'b' },
+                    c: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'c' },
+                    d: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'd' },
+                    e: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'e' },
+                    f: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'f' },
+                };
+                const expectedReturnValues = {
+                    a: { id: 1 },
+                    b: { id: 2 },
+                    c: { id: 3 },
+                    d: { id: 4 },
+                };
+                const expectedResultValues = {
+                    a: { status: ResultStatus.COMPLETE_SUCCESS, message: 'everything is fine' },
+                };
+                expectObservable(call.ack$).toBe(expectedAckMarbles, expectedAckValues);
+                expectObservable(call.return$).toBe(expectedRetMarbles, expectedReturnValues);
+                expectObservable(call.result$).toBe(expectedResMarbles, expectedResultValues);
+            });
+        });
+        it('should handle a failed call', () => {
+            // Arrange
+            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
+                return from([
+                    makeCallerMessage([ack('a')]),
+                    makeCallerMessage([ack('b')]),
+                    makeCallerMessage([ack('c'), ret(1)]),
+                    makeCallerMessage([ret(2)]),
+                    makeCallerMessage([ret(3), ret(4)]),
+                    makeCallerMessage([ack('d')]),
+                    makeCallerMessage([ack('e')]),
+                    makeCallerMessage([ack('f')]),
+                    makeCallerMessage([ack('g'), res(false)]),
+                    makeCallerMessage([ack('h')]),
+                ]).pipe(concatMap((item) => of(item).pipe(delay(1))));
+            });
+            testScheduler.run(({ expectObservable }) => {
+                // Act
+                const call = service.call({
+                    callsign: 'callsign',
+                    projectId: 'project',
+                    source: '/test',
+                });
+                // Assert
+                const expectedAckMarbles = '-abc--def#';
+                const expectedRetMarbles = '---ab(cd)#';
+                const expectedResMarbles = '---------(a|)';
+                const expectedAckValues = {
+                    a: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'a' },
+                    b: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'b' },
+                    c: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'c' },
+                    d: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'd' },
+                    e: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'e' },
+                    f: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'f' },
+                };
+                const expectedReturnValues = {
+                    a: { id: 1 },
+                    b: { id: 2 },
+                    c: { id: 3 },
+                    d: { id: 4 },
+                };
+                const expectedResultValues = {
+                    a: { status: ResultStatus.FATAL, message: 'nothing is fine' },
+                };
+                expectObservable(call.ack$).toBe(expectedAckMarbles, expectedAckValues, res(false).result);
+                expectObservable(call.return$).toBe(expectedRetMarbles, expectedReturnValues, res(false).result);
+                expectObservable(call.result$).toBe(expectedResMarbles, expectedResultValues);
+            });
+        });
+        it('should handle a successful chunked call', () => {
+            // Arrange
+            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
+                return from([
+                    ...makeCallerChunkedMessage([
+                        chunkRet('[{"'),
+                        chunkRet('id":1},'),
+                        ack('a'),
+                        chunkRet('{"id":2}'),
+                        ack('b'),
+                        chunkRet(']'),
+                    ]),
+                    makeCallerMessage([ack('c'), ret(3)]),
+                    makeCallerMessage([res(true)]),
+                ]).pipe(concatMap((item) => of(item).pipe(delay(1))));
+            });
+            testScheduler.run(({ expectObservable }) => {
+                // Act
+                const call = service.call({
+                    callsign: 'callsign',
+                    projectId: 'project',
+                    source: '/test',
+                });
+                // Assert
+                const expectedAckMarbles = '---a-b-c|';
+                const expectedRetMarbles = '------ab|';
+                const expectedResMarbles = '--------(a|)';
+                const expectedAckValues = {
+                    a: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'a' },
+                    b: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'b' },
+                    c: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'c' },
+                };
+                const expectedReturnValues = {
+                    a: [{ id: 1 }, { id: 2 }],
+                    b: { id: 3 },
+                };
+                const expectedResultValues = {
+                    a: { status: ResultStatus.COMPLETE_SUCCESS, message: 'everything is fine' },
+                };
+                expectObservable(call.ack$).toBe(expectedAckMarbles, expectedAckValues);
+                expectObservable(call.return$).toBe(expectedRetMarbles, expectedReturnValues);
+                expectObservable(call.result$).toBe(expectedResMarbles, expectedResultValues);
+            });
+        });
+    });
+});

package/esm/services/CallerServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { CallerService } from './CallerService';
+import { ICallerStream } from '../models/stream/ICallerStream';
+import { IStreamConfig } from '../models/IStreamConfig';
+export declare class CallerServiceNode extends CallerService {
+    protected getStream(config: IStreamConfig): ICallerStream;
+}

package/esm/services/CommandService.d.ts

@@ -0,0 +1,9 @@
+import { ICommandParams, ICommandStream, IRocosCommandMessage, IRocosSDKConfig, IStreamConfig } from '../models';
+import { Observable } from 'rxjs';
+import { BaseStreamService } from './BaseStreamService';
+export declare class CommandService extends BaseStreamService<ICommandStream> {
+    constructor(config: IRocosSDKConfig);
+    invokeRequest(params: ICommandParams): Observable<IRocosCommandMessage>;
+    protected createStream(): Promise<ICommandStream>;
+    protected getStream(config: IStreamConfig): ICommandStream;
+}

package/esm/services/CommandServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { CommandService } from './CommandService';
+import { ICommandStream } from '../models/stream/ICommandStream';
+import { IStreamConfig } from '../models/IStreamConfig';
+export declare class CommandServiceNode extends CommandService {
+    protected getStream(config: IStreamConfig): ICommandStream;
+}