@hahnpro/hpc-api 2025.2.0 → 2025.2.1

package/src/lib/data.service.js

@@ -1,16 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DataService", {
-    enumerable: true,
-    get: function() {
-        return DataService;
-    }
-});
-const _apibase = require("./api-base");
-const _datainterface = require("./data.interface");
-let DataService = class DataService extends _apibase.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);
     }
@@ -18,31 +8,25 @@ let DataService = class DataService extends _apibase.APIBase {
         return this.httpClient.post(`${this.basePath}/many`, dto, options);
     }
     getOne(id, options = {}) {
-        const params = options.populate ? {
-            populate: options.populate
-        } : {};
-        return this.httpClient.get(`${this.basePath}/${id}`, {
-            params
-        });
+        const params = options.populate ? { populate: options.populate } : {};
+        return this.httpClient.get(`${this.basePath}/${id}`, { params });
     }
     getMany(params = {}, options = {}) {
         params.limit = params.limit || 0;
         params.page = params.page || 1;
-        return this.httpClient.get(`${this.basePath}`, {
-            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 = {}) {
+     * 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);
     }
@@ -50,29 +34,24 @@ let DataService = class DataService extends _apibase.APIBase {
         return this.httpClient.put(`${this.basePath}/${id}`, dto, options);
     }
     deleteOne(id, force = false, options = {}) {
-        return this.httpClient.delete(`${this.basePath}/${id}`, {
-            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)){
+        for (const [key, value] of Object.entries(filter)) {
             if (value != null && value !== '') {
                 // filter out null and undefined values and empty strings
-                if (typeof value === 'object' && (0, _datainterface.instanceOfTimePeriod)(value)) {
+                if (typeof value === 'object' && instanceOfTimePeriod(value)) {
                     filters.push(`${key}>=${value.from.toISOString()};${key}<=${value.to.toISOString()}`);
-                } else if (Array.isArray(value)) {
+                }
+                else if (Array.isArray(value)) {
                     filters.push(`${key}=@${value.join(',')}`);
-                } else {
+                }
+                else {
                     filters.push(`${key}==${value}`);
                 }
             }
         }
         return filters.join(';');
     }
-};
-
-//# sourceMappingURL=data.service.js.map
+}

package/src/lib/endpoint.interface.js

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

package/src/lib/endpoint.service.js

@@ -1,16 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EndpointService", {
-    enumerable: true,
-    get: function() {
-        return EndpointService;
-    }
-});
-const _dataservice = require("./data.service");
-let EndpointService = class EndpointService extends _dataservice.DataService {
-    constructor(httpClient){
+import { DataService } from './data.service';
+export class EndpointService extends DataService {
+    constructor(httpClient) {
         super(httpClient, '/notification/endpoints');
     }
     sendNotification(endpointId, payload, options = {}) {
@@ -19,6 +9,4 @@ let EndpointService = class EndpointService extends _dataservice.DataService {
     readLastLogByGroup(endpointId, group, options = {}) {
         return this.httpClient.get(`${this.basePath}/${endpointId}/logs/${group}/last`, options);
     }
-};
-
-//# sourceMappingURL=endpoint.service.js.map
+}

package/src/lib/events.interface.js

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

package/src/lib/events.service.js

@@ -1,21 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EventsService", {
-    enumerable: true,
-    get: function() {
-        return EventsService;
-    }
-});
-const _dataservice = require("./data.service");
-let EventsService = class EventsService extends _dataservice.DataService {
-    constructor(httpClient){
+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);
     }
-};
-
-//# sourceMappingURL=events.service.js.map
+}

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

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

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

@@ -1,90 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FlowDeploymentService", {
-    enumerable: true,
-    get: function() {
-        return FlowDeploymentService;
-    }
-});
-const _ts_decorate = require("@swc/helpers/_/_ts_decorate");
-const _tsmixer = require("ts-mixer");
-const _apibase = require("./api-base");
-const _dataservice = require("./data.service");
-const _trashservice = require("./trash.service");
-let BaseService = class BaseService extends _apibase.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 = _ts_decorate._([
-    (0, _tsmixer.mix)(_dataservice.DataService, _trashservice.TrashService)
+BaseService = __decorate([
+    mix(DataService, TrashService)
 ], BaseService);
-let FlowDeploymentService = class FlowDeploymentService extends BaseService {
-    constructor(httpClient){
+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));
+        const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
     }
-    updateOne(id, dto, options = {
-        force: false
-    }) {
+    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
-        });
+        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
-        });
+        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);
+        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)) {
+        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 {
+                    }
+                    else {
                         reject(`Deployment in failed status: ${event.data}`);
                     }
                 }
-            }, (event)=>reject(event), options);
+            }, (event) => reject(event), options);
         });
     }
     addOne(dto, options = {}) {
@@ -96,6 +65,4 @@ let FlowDeploymentService = class FlowDeploymentService extends BaseService {
     subscribeToLogs(id, listener, errorListener, options = {}) {
         return this.httpClient.addEventSource(`${this.basePath}/${id}/logs/subscribe`, listener, errorListener, options);
     }
-};
-
-//# sourceMappingURL=flow-deployment.service.js.map
+}

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

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

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

@@ -1,34 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FlowFunctionService", {
-    enumerable: true,
-    get: function() {
-        return FlowFunctionService;
-    }
-});
-const _dataservice = require("./data.service");
-let FlowFunctionService = class FlowFunctionService extends _dataservice.DataService {
-    constructor(httpClient){
+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));
+        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);
+        return this.httpClient.put(`${this.basePath}/${fqn}/rollback`, { revisionId }, options);
     }
     deleteRevision(fqn, revisionId, options = {}) {
         return this.httpClient.delete(`${this.basePath}/${fqn}/revisions/${revisionId}`, options);
     }
-};
-
-//# sourceMappingURL=flow-function.service.js.map
+}

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

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

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

@@ -1,16 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FlowModuleService", {
-    enumerable: true,
-    get: function() {
-        return FlowModuleService;
-    }
-});
-const _dataservice = require("./data.service");
-let FlowModuleService = class FlowModuleService extends _dataservice.DataService {
-    constructor(httpClient){
+import { DataService } from './data.service';
+export class FlowModuleService extends DataService {
+    constructor(httpClient) {
         super(httpClient, '/flow/modules');
     }
     deleteArtifact(name, version, options = {}) {
@@ -18,12 +8,10 @@ let FlowModuleService = class FlowModuleService extends _dataservice.DataService
     }
     publish(form, options = {}) {
         const config = {
-            headers: {
-                ...form.getHeaders()
-            },
+            headers: { ...form.getHeaders() },
             maxBodyLength: Infinity,
             maxContentLength: Infinity,
-            ...options
+            ...options,
         };
         return this.httpClient.post(`${this.basePath}`, form, config);
     }
@@ -33,6 +21,4 @@ let FlowModuleService = class FlowModuleService extends _dataservice.DataService
     addMany(_dto) {
         throw new Error('not allowed: use publish instead');
     }
-};
-
-//# sourceMappingURL=flow-module.service.js.map
+}

package/src/lib/flow.interface.js

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

package/src/lib/flow.service.js

@@ -1,30 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FlowService", {
-    enumerable: true,
-    get: function() {
-        return FlowService;
-    }
-});
-const _ts_decorate = require("@swc/helpers/_/_ts_decorate");
-const _tsmixer = require("ts-mixer");
-const _apibase = require("./api-base");
-const _dataservice = require("./data.service");
-const _trashservice = require("./trash.service");
-let BaseService = class BaseService extends _apibase.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 = _ts_decorate._([
-    (0, _tsmixer.mix)(_dataservice.DataService, _trashservice.TrashService)
+BaseService = __decorate([
+    mix(DataService, TrashService)
 ], BaseService);
-let FlowService = class FlowService extends BaseService {
-    constructor(httpClient){
+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));
+        const reqs = dto.map((v) => this.addOne(v, options));
         return Promise.all(reqs);
     }
     getMany(params = {}, options = {}) {
@@ -51,13 +41,9 @@ let FlowService = class FlowService extends BaseService {
         return this.httpClient.get(`${this.basePath}/${id}/revisions`, options);
     }
     rollback(id, revisionId, options = {}) {
-        return this.httpClient.put(`${this.basePath}/${id}/rollback`, {
-            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);
     }
-};
-
-//# sourceMappingURL=flow.service.js.map
+}

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

@@ -46,7 +46,7 @@ export declare class HttpClient {
     protected exchangeAccessToken(accessToken: string): Promise<TokenSet>;
     provideExternalToken(token: string): Promise<void>;
 }
-interface Issuer {
+export interface Issuer {
     issuer: string;
     token_endpoint: string;
     grant_types_supported: string[];
@@ -54,4 +54,3 @@ interface Issuer {
     token_endpoint_auth_signing_alg?: string;
     token_endpoint_auth_signing_alg_values_supported: string[];
 }
-export {};