@hahnpro/hpc-api 5.3.4 → 2024.4.0-0

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/src/lib/flow-function.service.d.ts

@@ -0,0 +1,11 @@
+import { Paginated } from './data.interface';
+import { DataService } from './data.service';
+import { FlowFunctionDto } from './flow-function.interface';
+import { HttpClient, TokenOption } from './http.service';
+export declare class FlowFunctionService extends DataService<FlowFunctionDto> {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[], options?: TokenOption): Promise<FlowFunctionDto[]>;
+    getRevisions(fqn: string, options?: TokenOption): Promise<Paginated<FlowFunctionDto[]>>;
+    rollback(fqn: string, revisionId: string, options?: TokenOption): Promise<FlowFunctionDto>;
+    deleteRevision(fqn: string, revisionId: string, options?: TokenOption): Promise<any>;
+}

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

@@ -0,0 +1,20 @@
+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);
+    }
+    getRevisions(fqn, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${fqn}/revisions`, options);
+    }
+    rollback(fqn, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${fqn}/rollback`, { revisionId }, options);
+    }
+    deleteRevision(fqn, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${fqn}/revisions/${revisionId}`, options);
+    }
+}

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

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

package/src/lib/flow-module.service.d.ts

@@ -0,0 +1,11 @@
+import FormData from 'form-data';
+import { DataService } from './data.service';
+import { FlowModule } from './flow-module.interface';
+import { HttpClient, TokenOption } from './http.service';
+export declare class FlowModuleService extends DataService<FlowModule> {
+    constructor(httpClient: HttpClient);
+    deleteArtifact(name: string, version: string, options?: TokenOption): Promise<FlowModule>;
+    publish(form: FormData, options?: TokenOption): Promise<unknown>;
+    addOne(_dto: any): Promise<FlowModule>;
+    addMany(_dto: any[]): Promise<FlowModule[]>;
+}

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

@@ -1,27 +1,24 @@
-"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');
     }
-    deleteArtifact(name, version) {
-        return this.httpClient.delete(`${this.basePath}/${name}/${version}`);
+    deleteArtifact(name, version, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${name}/${version}`, options);
     }
-    publish(form) {
+    publish(form, options = {}) {
         const config = {
-            headers: Object.assign({}, form.getHeaders()),
+            headers: { ...form.getHeaders() },
             maxBodyLength: Infinity,
             maxContentLength: Infinity,
+            ...options,
         };
         return this.httpClient.post(`${this.basePath}`, form, config);
     }
-    addOne(dto) {
+    addOne(_dto) {
         throw new Error('not allowed: use publish instead');
     }
-    addMany(dto) {
+    addMany(_dto) {
         throw new Error('not allowed: use publish instead');
     }
 }
-exports.FlowModuleService = FlowModuleService;

package/src/lib/flow.interface.js

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

package/src/lib/flow.service.d.ts

@@ -0,0 +1,26 @@
+import { APIBase } from './api-base';
+import { Paginated, RequestParameter } from './data.interface';
+import { DataService } from './data.service';
+import { FlowDeployment } from './flow-deployment.interface';
+import { FlowDiagram, FlowDto } from './flow.interface';
+import { HttpClient, TokenOption } from './http.service';
+import { TrashService } from './trash.service';
+interface BaseService extends DataService<FlowDto>, TrashService<FlowDto> {
+}
+declare class BaseService extends APIBase {
+}
+export declare class FlowService extends BaseService {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[], options?: TokenOption): Promise<FlowDto[]>;
+    getMany(params?: RequestParameter, options?: TokenOption): Promise<Paginated<FlowDto[]>>;
+    getOne(id: string, options?: TokenOption & {
+        [key: string]: any;
+    }): Promise<FlowDto>;
+    getFlowWithDiagram(diagramId: string, options?: TokenOption): Promise<FlowDto>;
+    getDiagramRevisions(id: string, options?: TokenOption): Promise<FlowDiagram[]>;
+    isDeploymentOnLatestDiagramVersion(depl: FlowDeployment, options?: TokenOption): Promise<boolean>;
+    getRevisions(id: string, options?: TokenOption): Promise<Paginated<FlowDto[]>>;
+    rollback(id: string, revisionId: string, options?: TokenOption): Promise<FlowDto>;
+    deleteRevision(id: string, revisionId: string, options?: TokenOption): Promise<any>;
+}
+export {};

package/src/lib/flow.service.js

@@ -0,0 +1,49 @@
+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 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);
+    }
+    getMany(params = {}, options = {}) {
+        params.populate = params.populate ? params.populate : 'none';
+        return super.getMany(params, options);
+    }
+    getOne(id, options = {}) {
+        options.populate = options.populate ? options.populate : 'none';
+        return super.getOne(id, options);
+    }
+    getFlowWithDiagram(diagramId, options = {}) {
+        return this.httpClient.get(`${this.basePath}/diagram/${diagramId}`, options);
+    }
+    getDiagramRevisions(id, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${id}/diagram/revisions`, options);
+    }
+    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);
+    }
+    rollback(id, revisionId, options = {}) {
+        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId }, options);
+    }
+    deleteRevision(id, revisionId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`, options);
+    }
+}

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

@@ -2,6 +2,10 @@ import { AxiosInstance, AxiosRequestConfig, Method } from 'axios';
 import EventSource from 'eventsource';
 import { Queue } from './Queue';
 import { TokenSet } from './token-set';
+export type TokenOption = {
+    token?: string;
+};
+export type Config = TokenOption & AxiosRequestConfig;
 export declare class HttpClient {
     protected readonly baseURL: string;
     protected readonly authBaseURL: string;
@@ -14,6 +18,7 @@ export declare class HttpClient {
     protected readonly requestQueue: Queue;
     private tokenSet;
     private exchangedTokenSet;
+    private discoveredIssuers;
     eventSourcesMap: Map<string, {
         eventSource: EventSource;
         listener: (event: MessageEvent) => void;
@@ -26,12 +31,12 @@ export declare class HttpClient {
         size: number;
         total: number;
     };
-    delete: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
-    get: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
-    post: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
-    put: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
-    protected request: <T>(method: Method, url: string, config?: AxiosRequestConfig, data?: any) => Promise<T>;
-    addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    delete: <T>(url: string, config?: Config) => Promise<T>;
+    get: <T>(url: string, config?: Config) => Promise<T>;
+    post: <T>(url: string, data: any, config?: Config) => Promise<T>;
+    put: <T>(url: string, data: any, config?: Config) => Promise<T>;
+    protected request: <T>(method: Method, url: string, config?: Config, data?: any) => Promise<T>;
+    addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
     destroyEventSource(id: string): void;
     destroyAllEventSources(): void;
     getAccessToken: (forceRefresh?: boolean) => Promise<string>;
@@ -39,6 +44,7 @@ export declare class HttpClient {
     protected discoverIssuer(uri: string): Promise<Issuer>;
     protected requestAccessToken(additionalOpts?: {}): Promise<TokenSet>;
     protected exchangeAccessToken(accessToken: string): Promise<TokenSet>;
+    provideExternalToken(token: string): Promise<void>;
 }
 interface Issuer {
     issuer: string;

package/src/lib/http.service.js

@@ -0,0 +1,179 @@
+import { stringify } from 'querystring';
+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}`, {
+            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, stringify(opts), {
+            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/src/lib/label.service.d.ts

@@ -0,0 +1,9 @@
+import { DataService } from './data.service';
+import { HttpClient, TokenOption } from './http.service';
+import { Label } from './label.interface';
+export declare class LabelService extends DataService<Label> {
+    constructor(httpClient: HttpClient);
+    addMany(dtos: Label[], options?: TokenOption): Promise<Label[]>;
+    getOneByName(name: string, options?: TokenOption): Promise<Label>;
+    count(options?: TokenOption): Promise<number>;
+}

package/src/lib/label.service.js

@@ -0,0 +1,15 @@
+import { DataService } from './data.service';
+export class LabelService extends DataService {
+    constructor(httpClient) {
+        super(httpClient, '/labels');
+    }
+    addMany(dtos, options = {}) {
+        return Promise.all(dtos.map((dto) => this.addOne(dto, options)));
+    }
+    getOneByName(name, options = {}) {
+        return this.httpClient.get(`${this.basePath}/name/${name}`, options);
+    }
+    count(options = {}) {
+        return this.httpClient.get(`${this.basePath}/count`, options);
+    }
+}

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;
+    }
+}