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

package/cjs/services/CallerService.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerService = void 0;
+const splitRobotTopic_1 = require("../helpers/splitRobotTopic");
+const models_1 = require("../models");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const callerMessageHelpers_1 = require("../helpers/callerMessageHelpers");
+const BaseStreamService_1 = require("./BaseStreamService");
+const CallerStream_1 = require("../api/streams/caller/CallerStream");
+const identifier_1 = require("../constants/identifier");
+const uuid_1 = require("uuid");
+class CallerService extends BaseStreamService_1.BaseStreamService {
+    constructor(config) {
+        super('CallerService', config);
+    }
+    invokeRequest(params) {
+        const subject = new rxjs_1.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((0, operators_1.finalize)(() => {
+            subscription?.unsubscribe();
+        }));
+    }
+    cancelRequest(params) {
+        const subject = new rxjs_1.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((0, operators_1.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 } = (0, splitRobotTopic_1.splitRobotTopic)(params.source);
+        const payloadString = JSON.stringify(params.payload ?? {});
+        const source$ = this.invokeRequest({
+            uid: params.options?.uid ?? (0, uuid_1.v4)(),
+            projectId: params.projectId,
+            callsign: params.callsign,
+            subSystem: '',
+            component,
+            topic,
+            responseLevelNumber: models_1.RocosResponseLevel.ALL,
+            payload: payloadString,
+            query: params.options?.query,
+        }).pipe((0, rxjs_1.mergeMap)(callerMessageHelpers_1.getResponses), (0, callerMessageHelpers_1.handleChunkedMessages)());
+        const result$ = source$.pipe((0, operators_1.filter)((x) => x.result !== undefined), (0, rxjs_1.map)((x) => x.result), (0, rxjs_1.take)(1));
+        const resultNotifier$ = result$.pipe((0, rxjs_1.map)((x) => {
+            if (x.status !== models_1.ResultStatus.COMPLETE_SUCCESS)
+                throw x;
+            return x;
+        }));
+        const return$ = source$.pipe((0, operators_1.filter)((x) => x.return !== undefined), (0, rxjs_1.map)((x) => x.return), (0, rxjs_1.takeUntil)(resultNotifier$));
+        const ack$ = source$.pipe((0, operators_1.filter)((x) => x.ack !== undefined), (0, rxjs_1.map)((x) => x.ack), (0, rxjs_1.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((0, rxjs_1.map)((x) => {
+                const decoded = new TextDecoder().decode(x.payload);
+                return JSON.parse(decoded);
+            })),
+        };
+    }
+    async createStream() {
+        return (await this.createStreamFromConfig(identifier_1.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_1.CallerStream(config);
+    }
+}
+exports.CallerService = CallerService;

package/cjs/services/CallerService.spec.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../models");
+const rxjs_1 = require("rxjs");
+const CallerService_1 = require("./CallerService");
+const testing_1 = require("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: models_1.UIDVersion.HEADER_HASH_RAND,
+};
+const ack = (id) => ({
+    uid,
+    ack: {
+        status: models_1.AckStatus.PROGRESS,
+        message: id,
+        stage: models_1.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 ? models_1.ResultStatus.COMPLETE_SUCCESS : models_1.ResultStatus.FATAL,
+        message: ok ? 'everything is fine' : 'nothing is fine',
+    },
+});
+let testScheduler;
+let service;
+describe('CallerService', () => {
+    beforeEach(() => {
+        service = new CallerService_1.CallerService({
+            url: 'http://localhost:8080',
+            token: 'token',
+        });
+        testScheduler = new testing_1.TestScheduler((actual, expected) => {
+            expect(actual).toEqual(expected);
+        });
+    });
+    describe('callRaw', () => {
+        it('should handle a successful call', () => {
+            // Arrange
+            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
+                return (0, rxjs_1.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((0, rxjs_1.concatMap)((item) => (0, rxjs_1.of)(item).pipe((0, rxjs_1.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: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'a' },
+                    b: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'b' },
+                    c: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'c' },
+                    d: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'd' },
+                    e: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'e' },
+                    f: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'f' },
+                };
+                const expectedReturnValues = {
+                    a: { id: 1 },
+                    b: { id: 2 },
+                    c: { id: 3 },
+                    d: { id: 4 },
+                };
+                const expectedResultValues = {
+                    a: { status: models_1.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 (0, rxjs_1.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((0, rxjs_1.concatMap)((item) => (0, rxjs_1.of)(item).pipe((0, rxjs_1.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: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'a' },
+                    b: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'b' },
+                    c: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'c' },
+                    d: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'd' },
+                    e: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'e' },
+                    f: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'f' },
+                };
+                const expectedReturnValues = {
+                    a: { id: 1 },
+                    b: { id: 2 },
+                    c: { id: 3 },
+                    d: { id: 4 },
+                };
+                const expectedResultValues = {
+                    a: { status: models_1.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 (0, rxjs_1.from)([
+                    ...makeCallerChunkedMessage([
+                        chunkRet('[{"'),
+                        chunkRet('id":1},'),
+                        ack('a'),
+                        chunkRet('{"id":2}'),
+                        ack('b'),
+                        chunkRet(']'),
+                    ]),
+                    makeCallerMessage([ack('c'), ret(3)]),
+                    makeCallerMessage([res(true)]),
+                ]).pipe((0, rxjs_1.concatMap)((item) => (0, rxjs_1.of)(item).pipe((0, rxjs_1.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: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'a' },
+                    b: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'b' },
+                    c: { stage: models_1.Stage.AGENT, status: models_1.AckStatus.PROGRESS, message: 'c' },
+                };
+                const expectedReturnValues = {
+                    a: [{ id: 1 }, { id: 2 }],
+                    b: { id: 3 },
+                };
+                const expectedResultValues = {
+                    a: { status: models_1.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/cjs/services/CallerServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallerServiceNode = void 0;
+const CallerService_1 = require("./CallerService");
+const CallerStreamNode_1 = require("../api/streams/caller/CallerStreamNode");
+class CallerServiceNode extends CallerService_1.CallerService {
+    getStream(config) {
+        return new CallerStreamNode_1.CallerStreamNode(config);
+    }
+}
+exports.CallerServiceNode = CallerServiceNode;

package/cjs/services/CommandService.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandService = void 0;
+const rxjs_1 = require("rxjs");
+const BaseStreamService_1 = require("./BaseStreamService");
+const CommandStream_1 = require("../api/streams/command/CommandStream");
+const identifier_1 = require("../constants/identifier");
+const operators_1 = require("rxjs/operators");
+class CommandService extends BaseStreamService_1.BaseStreamService {
+    constructor(config) {
+        super('CommandService', config);
+    }
+    invokeRequest(params) {
+        const subject = new rxjs_1.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((0, operators_1.finalize)(() => {
+            subscription?.unsubscribe();
+        }));
+    }
+    async createStream() {
+        return (await this.createStreamFromConfig(identifier_1.IDENTIFIER_NAME_COMMAND, {
+            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 CommandStream_1.CommandStream(config);
+    }
+}
+exports.CommandService = CommandService;

package/cjs/services/CommandServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandServiceNode = void 0;
+const CommandService_1 = require("./CommandService");
+const CommandStreamNode_1 = require("../api/streams/command/CommandStreamNode");
+class CommandServiceNode extends CommandService_1.CommandService {
+    getStream(config) {
+        return new CommandStreamNode_1.CommandStreamNode(config);
+    }
+}
+exports.CommandServiceNode = CommandServiceNode;

package/cjs/services/ConfigGroupService.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigGroupService = 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 formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class ConfigGroupService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`ConfigGroupService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.CONFIG_GROUP_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param model - Payload {@link IConfigGroup}
+     */
+    // TODO: map the response object
+    async create(projectId, type, model) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_URL, { url: this.config.url, projectId, type }, this.config.insecure), model, `Failed to create config group for ${projectId}, type ${type}.`);
+    }
+    /**
+     * Get a config group list
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     */
+    // TODO: map the response object
+    async list(projectId, type) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_URL, { url: this.config.url, projectId, type }, this.config.insecure), `Failed to get config group list for ${projectId}, type ${type}.`);
+    }
+    /**
+     * Update a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param model - Payload {@link IConfigGroup}
+     */
+    // TODO: map the response object
+    async update(projectId, type, configGroupId, model) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_ID_URL, { url: this.config.url, projectId, type, configGroupId }, this.config.insecure), model, `Failed to update config group for ${projectId}, type ${type}, configGroupId ${configGroupId}.`);
+    }
+    /**
+     * Get a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     */
+    // TODO: map the response object
+    async info(projectId, type, configGroupId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_ID_URL, { url: this.config.url, projectId, type, configGroupId }, this.config.insecure), `Failed to get config group for ${projectId}, type ${type}, configGroupId ${configGroupId}.`);
+    }
+    /**
+     * Publish a config group
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param model - Payload {@link IConfigGroup}
+     */
+    // TODO: map the response object
+    async publish(projectId, type, configGroupId, model) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_PUBLISH_URL, { url: this.config.url, projectId, type, configGroupId }, this.config.insecure), model, `Failed to publish config group for ${projectId}, type ${type}, configGroupId ${configGroupId}.`);
+    }
+    /**
+     * Update a config
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param configId - Config Id
+     * @param content - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    async updateConfig(projectId, type, configGroupId, configId, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    content) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_CONFIG_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            configId,
+        }, this.config.insecure), content, `Failed to update config for ${projectId}, type ${type}, configGroupId ${configGroupId}, configId ${configId}.`);
+    }
+    /**
+     * Get a config group by version
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param version - Version
+     */
+    // TODO: map the response object
+    async getByVersion(projectId, type, configGroupId, version) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_VERSION_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            version,
+        }, this.config.insecure), `Failed to get config group for ${projectId}, type ${type}, configGroupId ${configGroupId}, version ${version}.`);
+    }
+    /**
+     * Override a config for owner
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param ownerId - Override Id
+     * @param content - Payload
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    async overrideByOwnerId(projectId, type, configGroupId, ownerId, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    content) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_OWNER_OVERRIDE_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            ownerId,
+        }, this.config.insecure), content, `Failed to override for ${projectId}, type ${type}, configGroupId ${configGroupId}, ownerId ${ownerId}.`);
+    }
+    /**
+     * Get an override config for owner
+     *
+     * @param projectId - Project Id
+     * @param type - Config group type
+     * @param configGroupId - Config group Id
+     * @param ownerId - Override Id
+     */
+    // TODO: map the response object
+    async getOverrideConfig(projectId, type, configGroupId, ownerId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_GROUP_TYPE_OWNER_ID_URL, {
+            url: this.config.url,
+            projectId,
+            type,
+            configGroupId,
+            ownerId,
+        }, this.config.insecure), `Failed to get override for ${projectId}, type ${type}, configGroupId ${configGroupId}, ownerId ${ownerId}.`);
+    }
+}
+exports.ConfigGroupService = ConfigGroupService;

package/cjs/services/ControlService.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlService = void 0;
+const rxjs_1 = require("rxjs");
+const BaseStreamService_1 = require("./BaseStreamService");
+const ControlStream_1 = require("../api/streams/control/ControlStream");
+const identifier_1 = require("../constants/identifier");
+const operators_1 = require("rxjs/operators");
+class ControlService extends BaseStreamService_1.BaseStreamService {
+    constructor(config) {
+        super('ControlService', config);
+    }
+    takeActionWithAck(action, params, ackTimeoutInSeconds = 15) {
+        const subject = new rxjs_1.Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.takeActionWithAck(action, params, ackTimeoutInSeconds).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('takeActionWithAck error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe((0, operators_1.finalize)(() => {
+            subscription?.unsubscribe();
+        }));
+    }
+    async sendCommand(params) {
+        const stream = await this.createStream();
+        return stream.sendCommand(params);
+    }
+    sendCommandWithAck(params) {
+        const subject = new rxjs_1.Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.sendCommandWithAck(params).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('sendCommandWithAck error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe((0, operators_1.finalize)(() => {
+            subscription?.unsubscribe();
+        }));
+    }
+    async createStream() {
+        return (await this.createStreamFromConfig(identifier_1.IDENTIFIER_NAME_CONTROL, {
+            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 ControlStream_1.ControlStream(config);
+    }
+}
+exports.ControlService = ControlService;

package/cjs/services/ControlServiceNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlServiceNode = void 0;
+const ControlService_1 = require("./ControlService");
+const ControlStreamNode_1 = require("../api/streams/control/ControlStreamNode");
+class ControlServiceNode extends ControlService_1.ControlService {
+    getStream(config) {
+        return new ControlStreamNode_1.ControlStreamNode(config);
+    }
+}
+exports.ControlServiceNode = ControlServiceNode;