@hahnpro/hpc-api 6.0.0 → 2024.4.0-1

package/src/lib/content.service.js

@@ -0,0 +1,49 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { ReturnType } from './content.interface';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class ContentService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/contents');
+        this.upload = (form, options = {}) => {
+            const headers = { ...form.getHeaders() };
+            return this.httpClient.post(`${this.basePath}`, form, {
+                headers,
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+                ...options,
+            });
+        };
+    }
+    async download(id, second, options = {}) {
+        let returnType;
+        if (typeof second === 'boolean' || second == null) {
+            returnType = second ? ReturnType.ARRAYBUFFER : ReturnType.BLOB;
+        }
+        else {
+            returnType = second;
+        }
+        const url = `${this.basePath}/${id}/download`;
+        switch (returnType) {
+            case ReturnType.TEXT:
+                return this.httpClient.get(url, { responseType: 'text', ...options });
+            case ReturnType.JSON:
+                return this.httpClient.get(url, { responseType: 'json', ...options });
+            case ReturnType.NODEBUFFER:
+                return Buffer.from(new Uint8Array(await this.httpClient.get(url, { responseType: 'arraybuffer', ...options })));
+            case ReturnType.BLOB:
+                return this.httpClient.get(url, { responseType: 'blob', ...options });
+            case ReturnType.ARRAYBUFFER:
+                return this.httpClient.get(url, { responseType: 'arraybuffer', ...options });
+            case ReturnType.NODESTREAM:
+                return this.httpClient.get(url, { responseType: 'stream', ...options });
+        }
+    }
+}

package/src/lib/data.interface.js

@@ -0,0 +1,3 @@
+export function instanceOfTimePeriod(object) {
+    return 'from' in object && 'to' in object;
+}

package/{dist → src/lib}/data.service.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataService = void 0;
-const api_base_1 = require("./api-base");
-const data_interface_1 = require("./data.interface");
-class DataService extends api_base_1.APIBase {
+import { APIBase } from './api-base';
+import { instanceOfTimePeriod } from './data.interface';
+export class DataService extends APIBase {
     addOne(dto, options = {}) {
         return this.httpClient.post(this.basePath, dto, options);
     }
@@ -17,8 +14,18 @@ class DataService extends api_base_1.APIBase {
     getMany(params = {}, options = {}) {
         params.limit = params.limit || 0;
         params.page = params.page || 1;
-        return this.httpClient.get(`${this.basePath}`, Object.assign({ params }, options));
-    }
+        return this.httpClient.get(`${this.basePath}`, { params, ...options });
+    }
+    /**
+     * Filters the elements by the passed properties. The object with these properties has to be of the form:
+     * {
+     *   propertyName: string | string[] | { from: Date, to: Date },
+     *   ...
+     * }.
+     * @param filter The Object with the properties to filter by.
+     * @param params Other request parameters.
+     * @param options Parameters for authentication
+     */
     getManyFiltered(filter, params = {}, options = {}) {
         params.filter = this.getFilterString(filter);
         return this.getMany(params, options);
@@ -27,13 +34,14 @@ class DataService extends api_base_1.APIBase {
         return this.httpClient.put(`${this.basePath}/${id}`, dto, options);
     }
     deleteOne(id, force = false, options = {}) {
-        return this.httpClient.delete(`${this.basePath}/${id}`, Object.assign({ params: { force } }, options));
+        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force }, ...options });
     }
     getFilterString(filter) {
         const filters = [];
         for (const [key, value] of Object.entries(filter)) {
             if (value != null && value !== '') {
-                if (typeof value === 'object' && (0, data_interface_1.instanceOfTimePeriod)(value)) {
+                // filter out null and undefined values and empty strings
+                if (typeof value === 'object' && instanceOfTimePeriod(value)) {
                     filters.push(`${key}>=${value.from.toISOString()};${key}<=${value.to.toISOString()}`);
                 }
                 else if (Array.isArray(value)) {
@@ -47,4 +55,3 @@ class DataService extends api_base_1.APIBase {
         return filters.join(';');
     }
 }
-exports.DataService = DataService;

package/src/lib/endpoint.interface.js

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

package/{dist → src/lib}/endpoint.service.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient, TokenOption } from './http.service';
 import { DataService } from './data.service';
-import { Endpoint, NotificationPayload, EndpointLog } from './endpoint.interface';
+import { Endpoint, EndpointLog, NotificationPayload } from './endpoint.interface';
+import { HttpClient, TokenOption } from './http.service';
 export declare class EndpointService extends DataService<Endpoint> {
     constructor(httpClient: HttpClient);
     sendNotification(endpointId: string, payload: NotificationPayload, options?: TokenOption): Promise<void>;

package/{dist → src/lib}/endpoint.service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EndpointService = void 0;
-const data_service_1 = require("./data.service");
-class EndpointService extends data_service_1.DataService {
+import { DataService } from './data.service';
+export class EndpointService extends DataService {
     constructor(httpClient) {
         super(httpClient, '/notification/endpoints');
     }
@@ -13,4 +10,3 @@ class EndpointService extends data_service_1.DataService {
         return this.httpClient.get(`${this.basePath}/${endpointId}/logs/${group}/last`, options);
     }
 }
-exports.EndpointService = EndpointService;

package/src/lib/events.interface.js

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

package/src/lib/events.service.js

@@ -0,0 +1,9 @@
+import { DataService } from './data.service';
+export class EventsService extends DataService {
+    constructor(httpClient) {
+        super(httpClient, '/events');
+    }
+    getLastEventByAssetAndGroup(assetId, group, options = {}) {
+        return this.httpClient.get(`${this.basePath}/last/${assetId}/${group}`, options);
+    }
+}

package/src/lib/flow-deployment.interface.js

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

package/src/lib/flow-deployment.service.js

@@ -0,0 +1,68 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class FlowDeploymentService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/flow/deployments');
+    }
+    // workaround as flow-deployment-service does not have a POST /many endpoint
+    addMany(dto, options = {}) {
+        const reqs = dto.map((v) => this.addOne(v, options));
+        return Promise.all(reqs);
+    }
+    updateOne(id, dto, options = { force: false }) {
+        return super.updateOne(id, dto, options);
+    }
+    getDeploymentStatistics(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/statistics`, options);
+    }
+    getDeploymentMetrics(id, range = '12h', interval = '5m', options = {}) {
+        const params = { range, interval };
+        return this.httpClient.get(`${this.basePath}/${id}/metrics`, { params, ...options });
+    }
+    getDeploymentLogs(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/logs`, options);
+    }
+    resolveReferences(id, recursive = true, types, options = {}) {
+        const params = { recursive, types: types?.join(',') ?? undefined };
+        return this.httpClient.get(`${this.basePath}/${id}/references`, { params, ...options });
+    }
+    updateStatus(id, desiredStatus, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/status`, { desiredStatus }, options);
+    }
+    deleteOne(id, _force, options = {}) {
+        return this.updateStatus(id, 'deleted', options);
+    }
+    async waitForRunningStatus(id, options = {}) {
+        return new Promise(async (resolve, reject) => {
+            const esId = await this.subscribeToStatus(id, (event) => {
+                if (event.type === 'message' &&
+                    ['running', 'deployment failed', 'deleted', 'generating failed', 'updating failed', 'upgrading failed'].includes(event.data)) {
+                    this.httpClient.destroyEventSource(esId);
+                    if (event.data === 'running') {
+                        resolve();
+                    }
+                    else {
+                        reject(`Deployment in failed status: ${event.data}`);
+                    }
+                }
+            }, (event) => reject(event), options);
+        });
+    }
+    addOne(dto, options = {}) {
+        return super.addOne(dto, options);
+    }
+    subscribeToStatus(id, listener, errorListener, options = {}) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/status`, listener, errorListener, options);
+    }
+    subscribeToLogs(id, listener, errorListener, options = {}) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/logs/subscribe`, listener, errorListener, options);
+    }
+}

package/src/lib/flow-function.interface.js

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

package/{dist → src/lib}/flow-function.service.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowFunctionService = void 0;
-const data_service_1 = require("./data.service");
-class FlowFunctionService extends data_service_1.DataService {
+import { DataService } from './data.service';
+export class FlowFunctionService extends DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/functions');
     }
+    // workaround as flow-functions-service does not have a POST /many endpoint
     addMany(dto, options = {}) {
         const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
@@ -20,4 +18,3 @@ class FlowFunctionService extends data_service_1.DataService {
         return this.httpClient.delete(`${this.basePath}/${fqn}/revisions/${revisionId}`, options);
     }
 }
-exports.FlowFunctionService = FlowFunctionService;

package/src/lib/flow-module.interface.js

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

package/{dist → src/lib}/flow-module.service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowModuleService = void 0;
-const data_service_1 = require("./data.service");
-class FlowModuleService extends data_service_1.DataService {
+import { DataService } from './data.service';
+export class FlowModuleService extends DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/modules');
     }
@@ -10,7 +7,12 @@ class FlowModuleService extends data_service_1.DataService {
         return this.httpClient.delete(`${this.basePath}/${name}/${version}`, options);
     }
     publish(form, options = {}) {
-        const config = Object.assign({ headers: Object.assign({}, form.getHeaders()), maxBodyLength: Infinity, maxContentLength: Infinity }, options);
+        const config = {
+            headers: { ...form.getHeaders() },
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+            ...options,
+        };
         return this.httpClient.post(`${this.basePath}`, form, config);
     }
     addOne(_dto) {
@@ -20,4 +22,3 @@ class FlowModuleService extends data_service_1.DataService {
         throw new Error('not allowed: use publish instead');
     }
 }
-exports.FlowModuleService = FlowModuleService;

package/src/lib/flow.interface.js

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

package/{dist → src/lib}/flow.service.js

@@ -1,20 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowService = void 0;
-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 trash_service_1 = require("./trash.service");
-let BaseService = class BaseService extends api_base_1.APIBase {
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
 };
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+BaseService = __decorate([
+    mix(DataService, TrashService)
 ], BaseService);
-class FlowService extends BaseService {
+export class FlowService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/flows');
     }
+    // workaround as flow-service does not have a POST /many endpoint
     addMany(dto, options = {}) {
         const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
@@ -33,13 +31,11 @@ class FlowService extends BaseService {
     getDiagramRevisions(id, options = {}) {
         return this.httpClient.get(`${this.basePath}/${id}/diagram/revisions`, options);
     }
-    isDeploymentOnLatestDiagramVersion(depl_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (depl, options = {}) {
-            const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
-            const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
-            const revisions = yield this.getDiagramRevisions(flowId, options);
-            return revisions[revisions.length - 1].id === diagramId;
-        });
+    async isDeploymentOnLatestDiagramVersion(depl, options = {}) {
+        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, options);
+        return revisions[revisions.length - 1].id === diagramId;
     }
     getRevisions(id, options = {}) {
         return this.httpClient.get(`${this.basePath}/${id}/revisions`, options);
@@ -51,4 +47,3 @@ class FlowService extends BaseService {
         return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`, options);
     }
 }
-exports.FlowService = FlowService;

package/{dist → src/lib}/http.service.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance, AxiosRequestConfig, Method } from 'axios';
-import EventSource from 'eventsource';
+import { EventSource } from 'eventsource';
 import { Queue } from './Queue';
 import { TokenSet } from './token-set';
 export type TokenOption = {

package/src/lib/http.service.js

@@ -0,0 +1,184 @@
+import axios from 'axios';
+import { EventSource } from 'eventsource';
+import { CompactSign, decodeJwt } from 'jose';
+import { Queue } from './Queue';
+import { TokenSet } from './token-set';
+export class HttpClient {
+    constructor(baseURL, authBaseURL, realm, clientId, clientSecret, tokenSubject) {
+        this.baseURL = baseURL;
+        this.authBaseURL = authBaseURL;
+        this.realm = realm;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.tokenSubject = tokenSubject;
+        this.discoveredIssuers = new Map();
+        this.eventSourcesMap = new Map();
+        this.getQueueStats = () => this.requestQueue?.getStats();
+        this.delete = (url, config) => this.request('DELETE', url, config);
+        this.get = (url, config) => this.request('GET', url, config);
+        this.post = (url, data, config) => this.request('POST', url, config, data);
+        this.put = (url, data, config) => this.request('PUT', url, config, data);
+        this.request = (method, url, config = {}, data) => {
+            return this.requestQueue.add(() => new Promise((resolve, reject) => {
+                const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();
+                tokenP
+                    .then((token) => {
+                    const headers = { Authorization: `Bearer ${token}`, ...config.headers };
+                    return this.axiosInstance.request({ ...config, headers, method, url, data });
+                })
+                    .then((response) => resolve(response.data))
+                    .catch(reject);
+            }));
+        };
+        this.getAccessToken = async (forceRefresh = false) => {
+            let accessToken;
+            if (forceRefresh || !this.tokenSet || this.tokenSet.isExpired()) {
+                if (this.tokenSet?.provided) {
+                    throw new Error('provided token is expired and cannot be refreshed, provide a new token.');
+                }
+                this.tokenSet = await this.requestAccessToken();
+                accessToken = this.tokenSet.accessToken;
+            }
+            else {
+                accessToken = this.tokenSet.accessToken;
+            }
+            if (this.tokenSubject) {
+                if (forceRefresh || !this.exchangedTokenSet || this.exchangedTokenSet.isExpired()) {
+                    this.exchangedTokenSet = await this.exchangeAccessToken(accessToken);
+                }
+                return this.exchangedTokenSet.accessToken;
+            }
+            else {
+                return accessToken;
+            }
+        };
+        this.axiosInstance = axios.create({ baseURL, timeout: 60000 });
+        this.authAxiosInstance = axios.create({ baseURL: authBaseURL || baseURL, timeout: 10000 });
+        this.requestQueue = new Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
+    }
+    async addEventSource(url, listener, errorListener, options = {}) {
+        const id = generateUUID();
+        const errListener = errorListener
+            ? errorListener
+            : (event) => {
+                throw new Error(JSON.stringify(event, null, 2));
+            };
+        const token = options.token ? options.token : await this.getAccessToken();
+        const es = new EventSource(`${this.baseURL}${url}`, {
+            fetch: (input, init) => fetch(input, {
+                ...init,
+                headers: {
+                    ...init.headers,
+                    Authorization: 'Bearer ' + token,
+                },
+            }),
+        });
+        es.addEventListener('message', listener);
+        es.addEventListener('error', errListener);
+        // the listeners have to be saved otherwise they cannot be removed
+        this.eventSourcesMap.set(id, { eventSource: es, listener, errListener });
+        return id;
+    }
+    destroyEventSource(id) {
+        if (!this.eventSourcesMap.has(id)) {
+            return;
+        }
+        const es = this.eventSourcesMap.get(id);
+        // close and unbind listeners so that the process quits cleanly
+        es.eventSource.close();
+        es.eventSource.removeEventListener('message', es.listener);
+        es.eventSource.removeEventListener('error', es.errListener);
+        this.eventSourcesMap.delete(id);
+    }
+    destroyAllEventSources() {
+        for (const key of this.eventSourcesMap.keys()) {
+            this.destroyEventSource(key);
+        }
+    }
+    validateIssuer(issuer) {
+        if (!issuer.issuer ||
+            !issuer.grant_types_supported?.includes('client_credentials') ||
+            !issuer.token_endpoint_auth_methods_supported?.includes('client_secret_jwt')) {
+            throw new Error('Issuer does not support client_secret_jwt');
+        }
+        return issuer;
+    }
+    async discoverIssuer(uri) {
+        if (this.discoveredIssuers.has(uri)) {
+            return this.discoveredIssuers.get(uri);
+        }
+        const wellKnownUri = `${uri}/.well-known/openid-configuration`;
+        const issuerResponse = await this.authAxiosInstance.get(wellKnownUri, {
+            responseType: 'json',
+            headers: { Accept: 'application/json' },
+        });
+        const validIssuer = this.validateIssuer(issuerResponse.data);
+        this.discoveredIssuers.set(uri, validIssuer);
+        return validIssuer;
+    }
+    async requestAccessToken(additionalOpts = {}) {
+        const issuer = await this.discoverIssuer(`${this.authBaseURL}/realms/${this.realm}`);
+        const timestamp = Date.now() / 1000;
+        const audience = [...new Set([issuer.issuer, issuer.token_endpoint].filter(Boolean))];
+        const assertionPayload = {
+            iat: timestamp,
+            exp: timestamp + 60,
+            jti: generateUUID(),
+            iss: this.clientId,
+            sub: this.clientId,
+            aud: audience,
+        };
+        const supportedAlgos = issuer.token_endpoint_auth_signing_alg_values_supported;
+        const alg = issuer.token_endpoint_auth_signing_alg ??
+            (Array.isArray(supportedAlgos) && supportedAlgos.find((signAlg) => /^HS(?:256|384|512)/.test(signAlg)));
+        if (!alg) {
+            throw new Error('Issuer has to support HS256, HS384 or HS512');
+        }
+        const assertion = await new CompactSign(Buffer.from(JSON.stringify(assertionPayload)))
+            .setProtectedHeader({ alg })
+            .sign(new TextEncoder().encode(this.clientSecret));
+        const opts = {
+            client_id: this.clientId,
+            client_assertion: assertion,
+            client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+            grant_type: 'client_credentials',
+            ...additionalOpts,
+        };
+        const authResponse = await this.authAxiosInstance.post(issuer.token_endpoint, new URLSearchParams(opts).toString(), {
+            headers: { Accept: 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        if (authResponse?.data?.access_token && authResponse.data.expires_in) {
+            return new TokenSet(authResponse.data.access_token, authResponse.data.expires_in);
+        }
+        else {
+            throw new Error('Invalid access token received');
+        }
+    }
+    async exchangeAccessToken(accessToken) {
+        if (!accessToken || !this.tokenSubject) {
+            throw new Error('Could not exchange access token');
+        }
+        const opts = {
+            grant_type: 'urn:ietf:params:oauth:grant-type:token-exchange',
+            subject_token: accessToken,
+            audience: this.clientId,
+            requested_token_type: 'urn:ietf:params:oauth:token-type:access_token',
+            requested_subject: this.tokenSubject,
+        };
+        return this.requestAccessToken(opts);
+    }
+    async provideExternalToken(token) {
+        const issuer = await this.discoverIssuer(`${this.authBaseURL}/realms/${this.realm}`);
+        const { iss: providedIssuer, exp } = decodeJwt(token);
+        if (issuer.issuer !== providedIssuer) {
+            throw new Error(`Provided token is not issued by currently configured issuer. Provided token issued by ${providedIssuer}, but ${issuer.issuer} is configured.`);
+        }
+        this.tokenSet = new TokenSet(token, exp - Date.now() / 1000, true);
+    }
+}
+function generateUUID() {
+    if (typeof globalThis.crypto?.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    throw new Error('randomUUID() not available in this environment. Please upgrade to Node 20+ or a modern browser.');
+}

package/src/lib/label.interface.js

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

package/{dist → src/lib}/label.service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LabelService = void 0;
-const data_service_1 = require("./data.service");
-class LabelService extends data_service_1.DataService {
+import { DataService } from './data.service';
+export class LabelService extends DataService {
     constructor(httpClient) {
         super(httpClient, '/labels');
     }
@@ -16,4 +13,3 @@ class LabelService extends data_service_1.DataService {
         return this.httpClient.get(`${this.basePath}/count`, options);
     }
 }
-exports.LabelService = LabelService;

package/src/lib/mock/api-base.mock.js

@@ -0,0 +1,7 @@
+import { APIBase } from '../api-base';
+export class APIBaseMock extends APIBase {
+    constructor(data = []) {
+        super(null, null);
+        this.data = data;
+    }
+}