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

package/esm/services/AuthService.spec.js

@@ -1,163 +0,0 @@
-import { issuer } from '../constants/auth';
-import { AuthService } from './AuthService';
-import { Token } from '../models';
-describe('authService', () => {
-    const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
-    beforeEach(() => {
-        jest.useFakeTimers();
-        jest.setSystemTime(baseDate);
-    });
-    const expiredDate = new Date(baseDate.getTime() - 1000 * 60 * 5); // 5 minutes ago
-    const almostExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 5); // 5 minutes from now
-    const almostAlmostExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 25); // 35 minutes from now
-    const notExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 60 * 24); // 1 day from now
-    const getToken = (config) => {
-        const header = {
-            alg: 'HS256',
-            typ: 'JWT',
-        };
-        const payload = {
-            iat: Math.floor((config.iat ?? expiredDate).getTime() / 1000),
-            exp: Math.floor((config.exp ?? notExpiredDate).getTime() / 1000),
-            iss: config.iss ?? issuer,
-            aud: config.aud ?? 'myaudience',
-            sub: config.sub ?? 'mysubject',
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64');
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64');
-        if (config.signature === false) {
-            return `${encodedHeader}.${encodedPayload}`;
-        }
-        return `${encodedHeader}.${encodedPayload}.signature`;
-    };
-    afterAll(() => jest.useRealTimers());
-    describe('getToken', () => {
-        it('should return the current token if it is not expired', async () => {
-            // Arrange
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            // Act
-            const newToken = await service.getToken();
-            // Assert
-            expect(newToken.value).toEqual(token);
-        });
-        it('should refresh the token if it is about to expire', async () => {
-            // Arrange
-            const token = getToken({ exp: almostExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            const expected = getToken({ signature: false });
-            jest.spyOn(AuthService.prototype, 'refreshToken').mockResolvedValue(new Token(expected));
-            // Act
-            const newToken = await service.getToken();
-            // Assert
-            expect(newToken.value).not.toEqual(token);
-            expect(newToken.value).toEqual(expected);
-            expect(AuthService.prototype.refreshToken).toHaveBeenCalled();
-        });
-        it('should get a new token if there is no current token', async () => {
-            // Arrange
-            const token = getToken({ signature: false });
-            const service = new AuthService({
-                url: 'http://localhost:0',
-                token,
-            });
-            service.clearToken();
-            const expected = getToken({ signature: false });
-            jest.spyOn(AuthService.prototype, 'getNewUserToken').mockResolvedValue(new Token(expected));
-            // Act
-            const newToken = await service.getToken();
-            // Assert
-            expect(newToken.value).toEqual(expected);
-            expect(AuthService.prototype.getNewUserToken).toHaveBeenCalled();
-        });
-    });
-    describe('tokenRefreshLoop', () => {
-        jest.spyOn(AuthService.prototype, 'refreshTokenIfExpired').mockImplementation(() => {
-            // make sure the promise is resolved synchronously
-            return {
-                catch: () => {
-                    return {
-                        finally(onfinally) {
-                            onfinally?.();
-                            return Promise.resolve();
-                        },
-                    };
-                },
-            };
-        });
-        beforeEach(() => {
-            jest.clearAllTimers();
-            jest.clearAllMocks();
-            jest.useFakeTimers();
-            jest.setSystemTime(baseDate);
-        });
-        it('should check the token every 10 minutes', async () => {
-            // Arrange
-            const token = getToken({ exp: almostAlmostExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            // Act
-            service.startTokenRefreshChecker();
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
-            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(2);
-            jest.advanceTimersByTime(1000 * 60); // 1 minutes - 24 minutes left
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(3);
-            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes - 14 minutes left
-            jest.runOnlyPendingTimers(); // wait for the next timer to run
-            service.stopTokenRefreshChecker();
-        });
-        it('should not run again when cancelled', () => {
-            // Arrange
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            // Act
-            service.startTokenRefreshChecker();
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
-            service.stopTokenRefreshChecker();
-            jest.runOnlyPendingTimers();
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
-        });
-        it('should correctly report running status', () => {
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-            service.startTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(true);
-            service.stopTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-        });
-        it('should correctly report running status', () => {
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-            service.startTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(true);
-            service.stopTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-        });
-    });
-});

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

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

package/esm/services/CallerService.spec.js

@@ -1,227 +0,0 @@
-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/FunctionService.d.ts

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

package/esm/services/FunctionService.js

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

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

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