@hahnpro/hpc-api 3.3.0 → 3.4.2

package/dist/api.js

@@ -20,7 +20,7 @@ const flow_deployment_service_1 = require("./flow-deployment.service");
 const label_service_1 = require("./label.service");
 class API {
     constructor() {
-        const normalizePath = (value = '', defaultValue = '') => value.replace(/^\/+|\/+$/g, '') || defaultValue;
+        const normalizePath = (value = '', defaultValue = '') => value.replace(/(?:^\/+)|(?:\/+$)/g, '') || defaultValue;
         let apiBaseUrl = process.env.API_BASE_URL || 'https://testing.hahnpro.com';
         if (!apiBaseUrl.startsWith('https') && !apiBaseUrl.startsWith('http')) {
             console.info('no protocol specified - using HTTPS');

package/dist/asset.service.d.ts

@@ -5,12 +5,11 @@ import { Paginated, RequestParameter } from './data.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<Asset>, TrashService<Asset> {
+interface BaseService extends DataService<Asset>, TrashService<Asset> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class AssetService extends MixedClass {
+export declare class AssetService extends BaseService {
     constructor(httpClient: HttpClient);
     deleteOne(id: string, force?: boolean): Promise<any>;
     addAttachment: (id: string, form: FormData) => Promise<Asset>;

package/dist/asset.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class AssetService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class AssetService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assets');
         this.addAttachment = (id, form) => {

package/dist/assettypes.service.d.ts

@@ -4,12 +4,11 @@ import { Paginated } from './data.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<AssetType>, TrashService<AssetType> {
+interface BaseService extends DataService<AssetType>, TrashService<AssetType> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class AssetTypesService extends MixedClass {
+export declare class AssetTypesService extends BaseService {
     constructor(httpClient: HttpClient);
     getRevisions(id: string): Promise<Paginated<AssetType[]>>;
     rollback(id: string, revisionId: string): Promise<AssetType>;

package/dist/assettypes.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class AssetTypesService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class AssetTypesService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assettypes');
     }

package/dist/content.service.d.ts

@@ -7,12 +7,11 @@ import { Content, ReturnType } from './content.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<Content>, TrashService<Content> {
+interface BaseService extends DataService<Content>, TrashService<Content> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class ContentService extends MixedClass {
+export declare class ContentService extends BaseService {
     constructor(httpClient: HttpClient);
     upload: (form: FormData) => Promise<Content>;
     download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;

package/dist/content.service.js

@@ -6,18 +6,13 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const content_interface_1 = require("./content.interface");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class ContentService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class ContentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/contents');
         this.upload = (form) => {

package/dist/data.service.d.ts

@@ -1,8 +1,6 @@
 import { APIBase } from './api-base';
 import { DataInterface, Filter, Paginated, RequestParameter } from './data.interface';
-import { HttpClient } from './http.service';
 export declare class DataService<T> extends APIBase implements DataInterface<T> {
-    constructor(httpClient: HttpClient, basePath: string);
     addOne(dto: any): Promise<T>;
     addMany(dto: any[]): Promise<T[]>;
     getOne(id: string, options?: any): Promise<T>;

package/dist/data.service.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataService = void 0;
 const api_base_1 = require("./api-base");
 class DataService extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
     addOne(dto) {
         return this.httpClient.post(this.basePath, dto);
     }

package/dist/flow-deployment.service.d.ts

@@ -4,12 +4,11 @@ import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog
 import { HttpClient } from './http.service';
 import { ResourceReference } from './resource.interface';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<FlowDeployment>, TrashService<FlowDeployment> {
+interface BaseService extends DataService<FlowDeployment>, TrashService<FlowDeployment> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class FlowDeploymentService extends MixedClass {
+export declare class FlowDeploymentService extends BaseService {
     constructor(httpClient: HttpClient);
     addMany(dto: any[]): Promise<FlowDeployment[]>;
     updateOne(id: string, dto: any, force?: boolean): Promise<FlowDeployment>;
@@ -17,7 +16,7 @@ export declare class FlowDeploymentService extends MixedClass {
     getDeploymentMetrics(id: string, range?: string, interval?: string): Promise<FlowDeploymentMetrics>;
     getDeploymentLogs(id: string): Promise<FlowLog[]>;
     resolveReferences(id: string, recursive?: boolean, types?: string[]): Promise<ResourceReference[]>;
-    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted'): Promise<FlowDeployment>;
+    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted' | 'paused'): Promise<FlowDeployment>;
     deleteOne(id: string): Promise<FlowDeployment>;
     waitForRunningStatus(id: string): Promise<void>;
     addOne(dto: {

package/dist/flow-deployment.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class FlowDeploymentService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class FlowDeploymentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flow/deployments');
     }

package/dist/flow.service.d.ts

@@ -5,12 +5,11 @@ import { FlowDiagram, FlowDto } from './flow.interface';
 import { FlowDeployment } from './flow-deployment.interface';
 import { HttpClient } from './http.service';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<FlowDto>, TrashService<FlowDto> {
+interface BaseService extends DataService<FlowDto>, TrashService<FlowDto> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class FlowService extends MixedClass {
+export declare class FlowService extends BaseService {
     constructor(httpClient: HttpClient);
     addMany(dto: any[]): Promise<FlowDto[]>;
     getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;

package/dist/flow.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class FlowService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class FlowService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flows');
     }
@@ -42,7 +37,7 @@ class FlowService extends MixedClass {
         const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
         const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
         const revisions = await this.getDiagramRevisions(flowId);
-        return revisions.reverse()[0].id === diagramId;
+        return revisions[revisions.length - 1].id === diagramId;
     }
     getRevisions(id) {
         return this.httpClient.get(`${this.basePath}/${id}/revisions`);

package/dist/http.service.d.ts

@@ -1,17 +1,21 @@
 import { AxiosRequestConfig } from 'axios';
 import EventSource from 'eventsource';
 export declare class HttpClient {
-    private baseURL;
+    private readonly baseURL;
+    private readonly authBaseURL;
     private readonly realm;
-    private readonly client;
-    private readonly secret;
+    private readonly clientId;
+    private readonly clientSecret;
     private readonly axiosInstance;
-    private readonly authAxiosInstance;
     private readonly requestQueue;
-    private accessToken;
-    private accessTokenExpiration;
-    eventSourcesMap: Map<string, EventSource>;
-    constructor(baseURL: string, authbaseURL: string, realm: string, client: string, secret: string);
+    private client;
+    private tokenSet;
+    eventSourcesMap: Map<string, {
+        eventSource: EventSource;
+        listener: (event: MessageEvent) => void;
+        errListener: (event: MessageEvent) => void;
+    }>;
+    constructor(baseURL: string, authBaseURL: string, realm: string, clientId: string, clientSecret: string);
     getQueueStats: () => {
         peak: number;
         pending: number;
@@ -27,6 +31,4 @@ export declare class HttpClient {
     destroyEventSource(id: string): void;
     destroyAllEventSources(): void;
     getAccessToken: () => Promise<string>;
-    private isTokenValid;
-    private getToken;
 }

package/dist/http.service.js

@@ -4,16 +4,17 @@ exports.HttpClient = void 0;
 const tslib_1 = require("tslib");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const eventsource_1 = tslib_1.__importDefault(require("eventsource"));
+const openid_client_1 = require("openid-client");
 const Queue_1 = require("./Queue");
 const crypto_1 = require("crypto");
-const EXPIRATION_BUFFER = 30 * 1000;
+const TOKEN_EXPIRATION_BUFFER = 30;
 class HttpClient {
-    constructor(baseURL, authbaseURL, realm, client, secret) {
+    constructor(baseURL, authBaseURL, realm, clientId, clientSecret) {
         this.baseURL = baseURL;
+        this.authBaseURL = authBaseURL;
         this.realm = realm;
-        this.client = client;
-        this.secret = secret;
-        this.accessTokenExpiration = 0;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
         this.eventSourcesMap = new Map();
         this.getQueueStats = () => { var _a; return (_a = this.requestQueue) === null || _a === void 0 ? void 0 : _a.getStats(); };
         this.delete = (url, config) => this.request('DELETE', url, config);
@@ -31,60 +32,37 @@ class HttpClient {
                     .catch(reject);
             }));
         };
-        this.getAccessToken = () => {
-            if (this.isTokenValid()) {
-                return Promise.resolve(this.accessToken);
+        this.getAccessToken = async () => {
+            var _a;
+            if (!((_a = this.client) === null || _a === void 0 ? void 0 : _a.issuer)) {
+                const authIssuer = await openid_client_1.Issuer.discover(`${this.authBaseURL}/realms/${this.realm}/`);
+                this.client = await new authIssuer.Client({
+                    client_id: this.clientId,
+                    client_secret: this.clientSecret,
+                    token_endpoint_auth_method: 'client_secret_jwt',
+                });
             }
-            else {
-                return this.getToken();
+            if (!this.tokenSet || this.tokenSet.expired() || this.tokenSet.expires_at < Date.now() / 1000 + TOKEN_EXPIRATION_BUFFER) {
+                this.tokenSet = await this.client.grant({ grant_type: 'client_credentials' });
             }
-        };
-        this.isTokenValid = () => {
-            if (this.accessToken && this.accessTokenExpiration) {
-                return Date.now() + EXPIRATION_BUFFER < this.accessTokenExpiration;
-            }
-            return false;
-        };
-        this.getToken = () => {
-            return new Promise((resolve, reject) => {
-                const params = new URLSearchParams([
-                    ['client_id', this.client],
-                    ['client_secret', this.secret],
-                    ['grant_type', 'client_credentials'],
-                ]);
-                const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
-                this.authAxiosInstance
-                    .post(`/realms/${this.realm}/protocol/openid-connect/token`, params.toString(), { headers })
-                    .then((res) => {
-                    var _a;
-                    if (((_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.access_token) && res.data.expires_in) {
-                        this.accessToken = res.data.access_token;
-                        this.accessTokenExpiration = Date.now() + res.data.expires_in * 1000;
-                        return resolve(res.data.access_token);
-                    }
-                    else {
-                        throw new Error('Invalid access token received');
-                    }
-                })
-                    .catch(reject);
-            });
+            return this.tokenSet.access_token;
         };
         this.axiosInstance = axios_1.default.create({ baseURL, timeout: 60000 });
-        this.authAxiosInstance = axios_1.default.create({ baseURL: authbaseURL || baseURL, timeout: 10000 });
         this.requestQueue = new Queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
     }
     async addEventSource(url, listener, errorListener) {
         const id = (0, crypto_1.randomUUID)();
+        const errListener = errorListener
+            ? errorListener
+            : (event) => {
+                throw new Error(JSON.stringify(event, null, 2));
+            };
         const es = new eventsource_1.default(`${this.baseURL}${url}`, {
             headers: { authorization: 'Bearer ' + (await this.getAccessToken()) },
         });
         es.addEventListener('message', listener);
-        es.addEventListener('error', errorListener
-            ? errorListener
-            : (event) => {
-                throw new Error(JSON.stringify(event, null, 2));
-            });
-        this.eventSourcesMap.set(id, es);
+        es.addEventListener('error', errListener);
+        this.eventSourcesMap.set(id, { eventSource: es, listener, errListener });
         return id;
     }
     destroyEventSource(id) {
@@ -92,9 +70,9 @@ class HttpClient {
             return;
         }
         const es = this.eventSourcesMap.get(id);
-        es.close();
-        es.removeEventListener('message', () => { });
-        es.removeEventListener('error', () => { });
+        es.eventSource.close();
+        es.eventSource.removeEventListener('message', es.listener);
+        es.eventSource.removeEventListener('error', es.errListener);
         this.eventSourcesMap.delete(id);
     }
     destroyAllEventSources() {

package/dist/mock/asset.mock.service.d.ts

@@ -6,12 +6,11 @@ import { MockAPI } from './api.mock';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<Asset>, TrashMockService<Asset> {
+interface BaseService extends DataMockService<Asset>, TrashMockService<Asset> {
 }
-declare class MixedClass extends APIBaseMock<Asset> {
-    constructor(data: Asset[]);
+declare class BaseService extends APIBaseMock<Asset> {
 }
-export declare class AssetMockService extends MixedClass implements AssetService {
+export declare class AssetMockService extends BaseService implements AssetService {
     private api;
     private revisions;
     constructor(api: MockAPI, assets: Asset[], revisions: AssetRevision[]);

package/dist/mock/asset.mock.service.js

@@ -6,16 +6,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class AssetMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class AssetMockService extends BaseService {
     constructor(api, assets, revisions) {
         super(assets);
         this.api = api;

package/dist/mock/assetTypes.mock.service.d.ts

@@ -4,12 +4,11 @@ import { Paginated, RequestParameter } from '../data.interface';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<AssetType>, TrashMockService<AssetType> {
+interface BaseService extends DataMockService<AssetType>, TrashMockService<AssetType> {
 }
-declare class MixedClass extends APIBaseMock<AssetType> {
-    constructor(data: AssetType[]);
+declare class BaseService extends APIBaseMock<AssetType> {
 }
-export declare class AssetTypesMockService extends MixedClass implements AssetTypesService {
+export declare class AssetTypesMockService extends BaseService implements AssetTypesService {
     private revisions;
     constructor(assetTypes: AssetType[], revisions: AssetTypeRevision[]);
     getMany(params?: RequestParameter): Promise<Paginated<AssetType[]>>;

package/dist/mock/assetTypes.mock.service.js

@@ -7,16 +7,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class AssetTypesMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class AssetTypesMockService extends BaseService {
     constructor(assetTypes, revisions) {
         super(assetTypes);
         this.revisions = revisions;

package/dist/mock/content.mock.service.d.ts

@@ -8,12 +8,11 @@ import { Paginated, RequestParameter } from '../data.interface';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<Content>, TrashMockService<Content> {
+interface BaseService extends DataMockService<Content>, TrashMockService<Content> {
 }
-declare class MixedClass extends APIBaseMock<Content> {
-    constructor(data: Content[]);
+declare class BaseService extends APIBaseMock<Content> {
 }
-export declare class ContentMockService extends MixedClass implements ContentService {
+export declare class ContentMockService extends BaseService implements ContentService {
     private contentData;
     constructor(contents: Content[], contentData: any[]);
     download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;

package/dist/mock/content.mock.service.js

@@ -8,16 +8,12 @@ const content_interface_1 = require("../content.interface");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class ContentMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class ContentMockService extends BaseService {
     constructor(contents, contentData) {
         super(contents);
         this.contentData = new Map();

package/dist/mock/flow-deployment.mock.service.d.ts

@@ -5,18 +5,17 @@ import { MockAPI } from './api.mock';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<FlowDeployment>, TrashMockService<FlowDeployment> {
+interface BaseService extends DataMockService<FlowDeployment>, TrashMockService<FlowDeployment> {
 }
-declare class MixedClass extends APIBaseMock<FlowDeployment> {
-    constructor(data: FlowDeployment[]);
+declare class BaseService extends APIBaseMock<FlowDeployment> {
 }
-export declare class FlowDeploymentMockService extends MixedClass implements FlowDeploymentService {
+export declare class FlowDeploymentMockService extends BaseService implements FlowDeploymentService {
     private api;
     constructor(deployments: FlowDeployment[], api: MockAPI);
     subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent<any>) => void): Promise<string>;
     subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
     waitForRunningStatus(id: string): Promise<void>;
-    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted'): Promise<FlowDeployment>;
+    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted' | 'paused'): Promise<FlowDeployment>;
     resolveReferences(id: string, recursive?: boolean, types?: string[]): Promise<ResourceReference[]>;
     getDeploymentStatistics(id: string): Promise<FlowDeploymentStatistic>;
     getDeploymentMetrics(id: string, range?: string, interval?: string): Promise<FlowDeploymentMetrics>;

package/dist/mock/flow-deployment.mock.service.js

@@ -7,16 +7,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class FlowDeploymentMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class FlowDeploymentMockService extends BaseService {
     constructor(deployments, api) {
         super(deployments);
         this.api = api;
@@ -117,12 +113,9 @@ class FlowDeploymentMockService extends MixedClass {
     }
     async getReferences(properties) {
         return Promise.all(Object.keys(properties).map(async (prop) => {
-            switch (prop) {
-                case 'assetId':
-                    return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
-                default:
-                    throw new Error('not implemented');
-            }
+            if (prop !== 'assetId')
+                throw new Error('not implemented');
+            return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
         }));
     }
 }

package/dist/mock/flow-functions.mock.service.js

@@ -20,8 +20,8 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
         this.revisions
             .filter((revision) => revision.originalId === fqn)
             .forEach((revision) => {
-            const index = this.revisions.indexOf(revision);
-            this.revisions.splice(index, 1);
+            const index1 = this.revisions.indexOf(revision);
+            this.revisions.splice(index1, 1);
         });
         return Promise.resolve(undefined);
     }

package/dist/mock/flow.mock.service.d.ts

@@ -5,12 +5,11 @@ import { FlowDeployment } from '../flow-deployment.interface';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<FlowDto>, TrashMockService<FlowDto> {
+interface BaseService extends DataMockService<FlowDto>, TrashMockService<FlowDto> {
 }
-declare class MixedClass extends APIBaseMock<FlowDto> {
-    constructor(data: FlowDto[]);
+declare class BaseService extends APIBaseMock<FlowDto> {
 }
-export declare class FlowMockService extends MixedClass implements FlowService {
+export declare class FlowMockService extends BaseService implements FlowService {
     private diagrams;
     private revisions;
     constructor(flows: FlowDto[], diagrams: FlowDiagram[], revisions: FlowRevision[]);

package/dist/mock/flow.mock.service.js

@@ -7,16 +7,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class FlowMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class FlowMockService extends BaseService {
     constructor(flows, diagrams, revisions) {
         super(flows);
         this.diagrams = diagrams;
@@ -50,7 +46,7 @@ class FlowMockService extends MixedClass {
         const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
         const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
         const revisions = await this.getDiagramRevisions(flowId);
-        return revisions.reverse()[0].id === diagramId;
+        return revisions[revisions.length - 1].id === diagramId;
     }
     getDiagramRevisions(id) {
         return Promise.resolve(this.diagrams.filter((v) => v.flow === id));

package/dist/mock/secret.mock.service.d.ts

@@ -4,12 +4,11 @@ import { Paginated, RequestParameter } from '../data.interface';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<Secret>, TrashMockService<Secret> {
+interface BaseService extends DataMockService<Secret>, TrashMockService<Secret> {
 }
-declare class MixedClass extends APIBaseMock<Secret> {
-    constructor(data: Secret[]);
+declare class BaseService extends APIBaseMock<Secret> {
 }
-export declare class SecretMockService extends MixedClass implements SecretService {
+export declare class SecretMockService extends BaseService implements SecretService {
     constructor(secrets: Secret[]);
     deleteOne(contentId: string, force?: boolean): Promise<Secret>;
     getMany(params?: RequestParameter): Promise<Paginated<Secret[]>>;

package/dist/mock/secret.mock.service.js

@@ -6,16 +6,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class SecretMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class SecretMockService extends BaseService {
     constructor(secrets) {
         super(secrets);
     }

package/dist/mock/task.mock.service.d.ts

@@ -4,12 +4,11 @@ import { TaskService } from '../task.service';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<Task>, TrashMockService<Task> {
+interface BaseService extends DataMockService<Task>, TrashMockService<Task> {
 }
-declare class MixedClass extends APIBaseMock<Task> {
-    constructor(data: Task[]);
+declare class BaseService extends APIBaseMock<Task> {
 }
-export declare class TaskMockService extends MixedClass implements TaskService {
+export declare class TaskMockService extends BaseService implements TaskService {
     constructor(tasks: Task[]);
     createTaskAttachedToAsset(dto: any): Promise<Task>;
     deleteOne(taskId: string, force?: boolean): Promise<Task>;

package/dist/mock/task.mock.service.js

@@ -6,16 +6,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class TaskMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class TaskMockService extends BaseService {
     constructor(tasks) {
         super(tasks);
     }

package/dist/mock/timeseries.mock.service.d.ts

@@ -4,20 +4,17 @@ import { TimeSeriesService } from '../timeseries.service';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
 import { TrashMockService } from './trash.mock.service';
-interface MixedClass extends DataMockService<TimeSeries & {
+interface BaseService extends DataMockService<TimeSeries & {
     data: TimeSeriesValue[];
 }>, TrashMockService<TimeSeries & {
     data: TimeSeriesValue[];
 }> {
 }
-declare class MixedClass extends APIBaseMock<TimeSeries & {
+declare class BaseService extends APIBaseMock<TimeSeries & {
     data: TimeSeriesValue[];
 }> {
-    constructor(data: (TimeSeries & {
-        data: TimeSeriesValue[];
-    })[]);
 }
-export declare class TimeseriesMockService extends MixedClass implements TimeSeriesService {
+export declare class TimeseriesMockService extends BaseService implements TimeSeriesService {
     constructor(timeseries: TimeSeries[], timeseriesValues: TimeSeriesValue[][]);
     deleteOne(tsmId: string, force?: boolean): Promise<TimeSeries>;
     getMany(params?: RequestParameter): Promise<Paginated<(TimeSeries & {

package/dist/mock/timeseries.mock.service.js

@@ -6,16 +6,12 @@ const ts_mixer_1 = require("ts-mixer");
 const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
 const trash_mock_service_1 = require("./trash.mock.service");
-let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
-    constructor(data) {
-        super(data);
-    }
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], MixedClass);
-class TimeseriesMockService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {
         const data = timeseries.map((value, index) => (Object.assign(Object.assign({}, value), { data: timeseriesValues[index] })));
         super(data);
@@ -56,7 +52,6 @@ class TimeseriesMockService extends MixedClass {
     async addValue(id, value) {
         const ts = await this.getOne(id, {});
         ts.data.push({ timestamp: new Date().valueOf(), value });
-        return;
     }
     getManyByAsset(assetId, names) {
         const page = { docs: [], limit: 10, total: 0 };

package/dist/secret.service.d.ts

@@ -3,12 +3,11 @@ import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { Secret } from './secret.interface';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<Secret>, TrashService<Secret> {
+interface BaseService extends DataService<Secret>, TrashService<Secret> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class SecretService extends MixedClass {
+export declare class SecretService extends BaseService {
     constructor(httpClient: HttpClient);
 }
 export {};

package/dist/secret.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class SecretService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class SecretService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/secrets');
     }

package/dist/task.service.d.ts

@@ -3,12 +3,11 @@ import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { Task } from './task.interface';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<Task>, TrashService<Task> {
+interface BaseService extends DataService<Task>, TrashService<Task> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class TaskService extends MixedClass {
+export declare class TaskService extends BaseService {
     constructor(httpClient: HttpClient);
     createTaskAttachedToAsset(dto: any): Promise<Task>;
 }

package/dist/task.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class TaskService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class TaskService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/tasks');
     }

package/dist/timeseries.service.d.ts

@@ -4,12 +4,11 @@ import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { TimeSeries, TimeSeriesValue, TS_GROUPS } from './timeseries.interface';
 import { TrashService } from './trash.service';
-interface MixedClass extends DataService<TimeSeries>, TrashService<TimeSeries> {
+interface BaseService extends DataService<TimeSeries>, TrashService<TimeSeries> {
 }
-declare class MixedClass extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
+declare class BaseService extends APIBase {
 }
-export declare class TimeSeriesService extends MixedClass {
+export declare class TimeSeriesService extends BaseService {
     constructor(httpClient: HttpClient);
     addValue(id: string, value: {
         [values: string]: any;

package/dist/timeseries.service.js

@@ -5,18 +5,13 @@ const tslib_1 = require("tslib");
 const ts_mixer_1 = require("ts-mixer");
 const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-const http_service_1 = require("./http.service");
 const trash_service_1 = require("./trash.service");
-let MixedClass = class MixedClass extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
+let BaseService = class BaseService extends api_base_1.APIBase {
 };
-MixedClass = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
-    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
-], MixedClass);
-class TimeSeriesService extends MixedClass {
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class TimeSeriesService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/tsm');
     }

package/dist/trash.service.d.ts

@@ -1,8 +1,6 @@
 import { APIBase } from './api-base';
 import { Paginated, RequestParameter } from './data.interface';
-import { HttpClient } from './http.service';
 export declare class TrashService<T> extends APIBase {
-    constructor(httpClient: HttpClient, basePath: string);
     trashRestoreAll(): Promise<T[]>;
     trashRestoreOne(id: string): Promise<T>;
     emptyTrash(offset: number): Promise<{

package/dist/trash.service.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrashService = void 0;
 const api_base_1 = require("./api-base");
 class TrashService extends api_base_1.APIBase {
-    constructor(httpClient, basePath) {
-        super(httpClient, basePath);
-    }
     trashRestoreAll() {
         return this.httpClient.put(`${this.basePath}/trash/restore`, {});
     }

package/dist/user-settings.interface.d.ts

@@ -0,0 +1,29 @@
+export interface UserSettings {
+    userId: string;
+    language: string;
+    activeRoles: Permission[];
+    creationReadRoles: Permission[];
+    creationWriteRoles: Permission[];
+    activeTags: string[];
+    applications: Application[];
+    tableSettings: TableSetting[];
+    favoriteLabelsOrder: Record<string, number>;
+}
+export interface Application {
+    name: string;
+    currentColumnSettings?: string;
+    columnSettings?: string[];
+}
+export interface Permission {
+    label: string;
+    value: string;
+}
+export interface TableSettingProfile {
+    name: string;
+    cols: string;
+}
+export interface TableSetting {
+    name: string;
+    currentProfile: string;
+    profiles: TableSettingProfile[];
+}

package/dist/user-settings.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/user.service.d.ts

@@ -1,6 +1,11 @@
 import { HttpClient } from './http.service';
+import { UserSettings } from './user-settings.interface';
 export declare class UserService {
     private httpClient;
+    private readonly basePath;
     constructor(httpClient: HttpClient);
     getCurrentUserRoles(): Promise<string[]>;
+    getUserSettings(): Promise<UserSettings>;
+    updateUserSettings(settings: UserSettings): Promise<UserSettings>;
+    deleteUserSettings(): Promise<UserSettings>;
 }

package/dist/user.service.js

@@ -6,6 +6,7 @@ const jwt_decode_1 = tslib_1.__importDefault(require("jwt-decode"));
 class UserService {
     constructor(httpClient) {
         this.httpClient = httpClient;
+        this.basePath = '/user';
     }
     async getCurrentUserRoles() {
         try {
@@ -17,5 +18,14 @@ class UserService {
             return null;
         }
     }
+    getUserSettings() {
+        return this.httpClient.get(this.basePath);
+    }
+    updateUserSettings(settings) {
+        return this.httpClient.put(this.basePath, settings);
+    }
+    deleteUserSettings() {
+        return this.httpClient.delete(this.basePath);
+    }
 }
 exports.UserService = UserService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "3.3.0",
+  "version": "3.4.2",
   "description": "Module for easy access to the HahnPRO API",
   "license": "MIT",
   "author": {
@@ -28,12 +28,14 @@
     "eventsource": "^2.0.2",
     "form-data": "^4.0.0",
     "jwt-decode": "^3.1.2",
+    "openid-client": "^5.1.8",
     "p-queue": "^6.6.2",
     "ts-mixer": "^6.0.1"
   },
   "devDependencies": {
     "@types/eventsource": "^1.1.9",
-    "axios-mock-adapter": "^1.21.1"
+    "axios-mock-adapter": "^1.21.2",
+    "nock": "^13.2.9"
   },
   "engines": {
     "node": ">=v14.13"