@hahnpro/hpc-api 2025.2.0 → 2025.2.1

package/src/lib/http.service.js

@@ -1,21 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "HttpClient", {
-    enumerable: true,
-    get: function() {
-        return HttpClient;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _axios = /*#__PURE__*/ _interop_require_default._(require("axios"));
-const _eventsource = require("eventsource");
-const _jose = require("jose");
-const _Queue = require("./Queue");
-const _tokenset = require("./token-set");
-let HttpClient = class HttpClient {
-    constructor(baseURL, authBaseURL, realm, clientId, clientSecret, tokenSubject){
+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;
@@ -24,30 +13,24 @@ let HttpClient = class HttpClient {
         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.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)=>{
+        this.getAccessToken = async (forceRefresh = false) => {
             let accessToken;
             if (forceRefresh || !this.tokenSet || this.tokenSet.isExpired()) {
                 if (this.tokenSet?.provided) {
@@ -55,7 +38,8 @@ let HttpClient = class HttpClient {
                 }
                 this.tokenSet = await this.requestAccessToken();
                 accessToken = this.tokenSet.accessToken;
-            } else {
+            }
+            else {
                 accessToken = this.tokenSet.accessToken;
             }
             if (this.tokenSubject) {
@@ -63,47 +47,36 @@ let HttpClient = class HttpClient {
                     this.exchangedTokenSet = await this.exchangeAccessToken(accessToken);
                 }
                 return this.exchangedTokenSet.accessToken;
-            } else {
+            }
+            else {
                 return accessToken;
             }
         };
-        this.axiosInstance = _axios.default.create({
-            baseURL,
-            timeout: 60000
-        });
-        this.authAxiosInstance = _axios.default.create({
-            baseURL: authBaseURL || baseURL,
-            timeout: 10000
-        });
-        this.requestQueue = new _Queue.Queue({
-            concurrency: 1,
-            timeout: 70000,
-            throwOnTimeout: true
-        });
+        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 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.EventSource(`${this.baseURL}${url}`, {
-            fetch: (input, init)=>fetch(input, {
-                    ...init,
-                    headers: {
-                        ...init.headers,
-                        Authorization: 'Bearer ' + token
-                    }
-                })
+        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
-        });
+        this.eventSourcesMap.set(id, { eventSource: es, listener, errListener });
         return id;
     }
     destroyEventSource(id) {
@@ -118,12 +91,14 @@ let HttpClient = class HttpClient {
         this.eventSourcesMap.delete(id);
     }
     destroyAllEventSources() {
-        for (const key of this.eventSourcesMap.keys()){
+        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')) {
+        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;
@@ -135,9 +110,7 @@ let HttpClient = class HttpClient {
         const wellKnownUri = `${uri}/.well-known/openid-configuration`;
         const issuerResponse = await this.authAxiosInstance.get(wellKnownUri, {
             responseType: 'json',
-            headers: {
-                Accept: 'application/json'
-            }
+            headers: { Accept: 'application/json' },
         });
         const validIssuer = this.validateIssuer(issuerResponse.data);
         this.discoveredIssuers.set(uri, validIssuer);
@@ -146,44 +119,38 @@ let HttpClient = class HttpClient {
     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 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
+            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)));
+        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 _jose.CompactSign(Buffer.from(JSON.stringify(assertionPayload))).setProtectedHeader({
-            alg
-        }).sign(new TextEncoder().encode(this.clientSecret));
+        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
+            ...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'
-            }
+            headers: { Accept: 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' },
         });
         if (authResponse?.data?.access_token && authResponse.data.expires_in) {
-            return new _tokenset.TokenSet(authResponse.data.access_token, authResponse.data.expires_in);
-        } else {
+            return new TokenSet(authResponse.data.access_token, authResponse.data.expires_in);
+        }
+        else {
             throw new Error('Invalid access token received');
         }
     }
@@ -196,24 +163,22 @@ let HttpClient = class HttpClient {
             subject_token: accessToken,
             audience: this.clientId,
             requested_token_type: 'urn:ietf:params:oauth:token-type:access_token',
-            requested_subject: this.tokenSubject
+            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 } = (0, _jose.decodeJwt)(token);
+        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.TokenSet(token, exp - Date.now() / 1000, true);
+        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.');
 }
-
-//# sourceMappingURL=http.service.js.map

package/src/lib/label.interface.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-//# sourceMappingURL=label.interface.js.map
+export {};

package/src/lib/label.service.js

@@ -1,20 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "LabelService", {
-    enumerable: true,
-    get: function() {
-        return LabelService;
-    }
-});
-const _dataservice = require("./data.service");
-let LabelService = class LabelService extends _dataservice.DataService {
-    constructor(httpClient){
+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)));
+        return Promise.all(dtos.map((dto) => this.addOne(dto, options)));
     }
     getOneByName(name, options = {}) {
         return this.httpClient.get(`${this.basePath}/name/${name}`, options);
@@ -22,6 +12,4 @@ let LabelService = class LabelService extends _dataservice.DataService {
     count(options = {}) {
         return this.httpClient.get(`${this.basePath}/count`, options);
     }
-};
-
-//# sourceMappingURL=label.service.js.map
+}

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

@@ -1,18 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "APIBaseMock", {
-    enumerable: true,
-    get: function() {
-        return APIBaseMock;
+import { APIBase } from '../api-base';
+export class APIBaseMock extends APIBase {
+    constructor(data = []) {
+        super(null, null);
+        this.data = data;
     }
-});
-const _apibase = require("../api-base");
-let APIBaseMock = class APIBaseMock extends _apibase.APIBase {
-    constructor(data = []){
-        super(null, null), this.data = data;
-    }
-};
-
-//# sourceMappingURL=api-base.mock.js.map
+}

package/src/lib/mock/api.mock.d.ts

@@ -23,6 +23,7 @@ import { AssetTypesMockService } from './assetTypes.mock.service';
 import { ContentMockService } from './content.mock.service';
 import { EndpointMockService } from './endpoint.mock.service';
 import { EventsMockService } from './events.mock.service';
+import { HttpMockService } from './http.mock.service';
 import { LabelMockService } from './label.mock.service';
 import { NotificationMockService } from './notification.mock.service';
 import { SecretMockService } from './secret.mock.service';
@@ -30,8 +31,29 @@ import { TaskMockService } from './task.mock.service';
 import { TimeseriesMockService } from './timeseries.mock.service';
 import { UserMockService } from './user.mock.service';
 import { VaultMockService } from './vault.mock.service';
+export interface MockAPIInitData {
+    assets?: AssetInit[];
+    assetRevisions?: AssetRevisionInit[];
+    contents?: ContentInit[];
+    endpoints?: EndpointInit[];
+    secrets?: SecretInit[];
+    timeSeries?: TimeSeriesInit[];
+    tasks?: TaskInit[];
+    events?: EventInit[];
+    users?: UserInit;
+    flows?: FlowInit[];
+    flowRevisions?: FlowRevisionInit[];
+    deployments?: FlowDeploymentInit[];
+    functions?: FlowFunctionInit[];
+    functionRevisions?: FlowFunctionRevisionInit[];
+    modules?: FlowModuleInit[];
+    diagrams?: FlowDiagramInit[];
+    labels?: LabelInit[];
+    vault?: VaultSecretInit[];
+    notifications?: NotificationInit[];
+}
 export declare class MockAPI implements API {
-    httpClient: any;
+    httpClient: HttpMockService;
     assets: AssetMockService;
     assetTypes: AssetTypesMockService;
     contents: ContentMockService;
@@ -49,27 +71,7 @@ export declare class MockAPI implements API {
     users: UserMockService;
     vault: VaultMockService;
     notifications: NotificationMockService;
-    constructor(initData: {
-        assets?: AssetInit[];
-        assetRevisions?: AssetRevisionInit[];
-        contents?: ContentInit[];
-        endpoints?: EndpointInit[];
-        secrets?: SecretInit[];
-        timeSeries?: TimeSeriesInit[];
-        tasks?: TaskInit[];
-        events?: EventInit[];
-        users?: UserInit;
-        flows?: FlowInit[];
-        flowRevisions?: FlowRevisionInit[];
-        deployments?: FlowDeploymentInit[];
-        functions?: FlowFunctionInit[];
-        functionRevisions?: FlowFunctionRevisionInit[];
-        modules?: FlowModuleInit[];
-        diagrams?: FlowDiagramInit[];
-        labels?: LabelInit[];
-        vault?: VaultSecretInit[];
-        notifications?: NotificationInit[];
-    });
+    constructor(initData: MockAPIInitData);
 }
 export type Identity<T> = {
     [P in keyof T]: T[P];