@hahnpro/hpc-api 2.1.1 → 2.2.0

package/dist/Queue.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Queue = void 0;
 const tslib_1 = require("tslib");
-const p_queue_1 = (0, tslib_1.__importDefault)(require("p-queue"));
+const p_queue_1 = tslib_1.__importDefault(require("p-queue"));
 class Queue extends p_queue_1.default {
     constructor(options) {
         super(options);

package/dist/api.d.ts

@@ -10,6 +10,10 @@ import { SiDriveIqService } from './sidriveiq.service';
 import { TaskService } from './task.service';
 import { TimeSeriesService } from './timeseries.service';
 import { UserService } from './user.service';
+import { FlowService } from './flow.service';
+import { FlowFunctionService } from './flow-function.service';
+import { FlowModuleService } from './flow-module.service';
+import { FlowDeploymentService } from './flow-deployment.service';
 export declare class API {
     httpClient: HttpClient;
     assets: AssetService;
@@ -17,6 +21,10 @@ export declare class API {
     contents: ContentService;
     endpoints: EndpointService;
     events: EventsService;
+    flows: FlowService;
+    flowDeployments: FlowDeploymentService;
+    flowFunctions: FlowFunctionService;
+    flowModules: FlowModuleService;
     proxy: ProxyService;
     secrets: SecretService;
     tasks: TaskService;

package/dist/api.js

@@ -13,6 +13,10 @@ const sidriveiq_service_1 = require("./sidriveiq.service");
 const task_service_1 = require("./task.service");
 const timeseries_service_1 = require("./timeseries.service");
 const user_service_1 = require("./user.service");
+const flow_service_1 = require("./flow.service");
+const flow_function_service_1 = require("./flow-function.service");
+const flow_module_service_1 = require("./flow-module.service");
+const flow_deployment_service_1 = require("./flow-deployment.service");
 class API {
     constructor() {
         const normalizePath = (value = '', defaultValue = '') => value.replace(/^\/+|\/+$/g, '') || defaultValue;
@@ -36,6 +40,10 @@ class API {
         this.contents = new content_service_1.ContentService(this.httpClient);
         this.endpoints = new endpoint_service_1.EndpointService(this.httpClient);
         this.events = new events_service_1.EventsService(this.httpClient);
+        this.flows = new flow_service_1.FlowService(this.httpClient);
+        this.flowDeployments = new flow_deployment_service_1.FlowDeploymentService(this.httpClient);
+        this.flowFunctions = new flow_function_service_1.FlowFunctionService(this.httpClient);
+        this.flowModules = new flow_module_service_1.FlowModuleService(this.httpClient);
         this.proxy = new proxy_service_1.ProxyService(this.httpClient);
         this.secrets = new secret_service_1.SecretService(this.httpClient);
         this.tasks = new task_service_1.TaskService(this.httpClient);

package/dist/content.interface.d.ts

@@ -1,15 +1,4 @@
-declare type FileType = 'original' | 'preview-sm' | 'preview-md' | 'preview-lg';
-declare type StorageProvider = 's3' | 'mongo';
-export interface Storage {
-    id: string;
-    filename: string;
-    mimetype: string;
-    size: number;
-    createdAt: string;
-    provider?: StorageProvider;
-    type?: FileType;
-    md5?: string;
-}
+import { Storage } from './storage.interface';
 export interface Content {
     id?: string;
     fileId: string;
@@ -32,4 +21,3 @@ export declare enum ReturnType {
     ARRAYBUFFER = 4,
     NODESTREAM = 5
 }
-export {};

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

@@ -0,0 +1,76 @@
+import { Resource } from './resource.interface';
+import { FlowDiagram, FlowDto } from './flow.interface';
+import { Storage } from './storage.interface';
+export interface FlowDeployment extends Resource {
+    flow: string | FlowDto;
+    diagram: string | FlowDiagram;
+    artifact: Storage;
+    flowModel: FlowModel;
+    desiredStatus: string;
+    actualStatus: string;
+    target: string;
+    statistic?: FlowDeploymentStatistic;
+}
+export interface FlowDeploymentStatistic {
+    totalErrorCount: number;
+    errorCountWeek: number;
+    eventCountWeek: number;
+    errorCounts: {
+        timestamp: number;
+        error: number;
+    }[];
+    metrics?: Record<string, any>;
+}
+export interface FlowModel {
+    elements: FlowModelElement[];
+    connections: FlowConnection[];
+    modules?: string[];
+    properties?: Record<string, any>;
+}
+export interface FlowModelElement {
+    id: string;
+    name?: string;
+    properties?: Record<string, any>;
+    module: string;
+    functionFqn: string;
+}
+export interface FlowConnection {
+    id: string;
+    name?: string;
+    source: string;
+    target: string;
+    sourceStream?: string;
+    targetStream?: string;
+}
+export interface FlowDeploymentMetrics {
+    metrics: Metrics[];
+    stats?: Stats;
+}
+export interface Metrics {
+    timestamp: number;
+    cpu: number;
+    memory: number;
+}
+export interface Stats {
+    cpu: StatsValues;
+    memory: StatsValues;
+}
+export interface StatsValues {
+    count: number;
+    min: number;
+    max: number;
+    avg: number;
+    sum: number;
+}
+export interface FlowLog {
+    data?: any;
+    datacontenttype?: string;
+    deploymentId?: string;
+    elementId?: string;
+    eventId?: string;
+    flowId?: string;
+    subject: string;
+    source?: string;
+    time: string;
+    type: string;
+}

package/dist/flow-deployment.interface.js

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

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

@@ -0,0 +1,26 @@
+import { DataService } from './data.service';
+import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from './flow-deployment.interface';
+import { HttpClient } from './http.service';
+import { ResourceReference } from './resource.interface';
+export declare class FlowDeploymentService extends DataService<FlowDeployment> {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[]): Promise<FlowDeployment[]>;
+    updateOne(id: string, dto: any, force?: boolean): Promise<FlowDeployment>;
+    getDeploymentStatistics(id: string): Promise<FlowDeploymentStatistic>;
+    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>;
+    deleteOne(id: string): Promise<FlowDeployment>;
+    waitForRunningStatus(id: string): Promise<void>;
+    addOne(dto: {
+        diagramId: string;
+        name: string;
+        properties?: Record<string, any>;
+        readPermissions?: string[];
+        readWritePermissions?: string[];
+        tags?: string[];
+    }): Promise<FlowDeployment>;
+    subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+}

package/dist/flow-deployment.service.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowDeploymentService = void 0;
+const data_service_1 = require("./data.service");
+class FlowDeploymentService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flow/deployments');
+    }
+    addMany(dto) {
+        const reqs = dto.map((v) => this.addOne(v));
+        return Promise.all(reqs);
+    }
+    updateOne(id, dto, force = false) {
+        return this.httpClient.put(`${this.basePath}/${id}`, dto, { params: { force } });
+    }
+    getDeploymentStatistics(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/statistics`);
+    }
+    getDeploymentMetrics(id, range = '12h', interval = '5m') {
+        const params = { range, interval };
+        return this.httpClient.get(`${this.basePath}/${id}/metrics`, { params });
+    }
+    getDeploymentLogs(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/logs`);
+    }
+    resolveReferences(id, recursive = true, types) {
+        var _a;
+        const params = { recursive, types: (_a = types === null || types === void 0 ? void 0 : types.join(',')) !== null && _a !== void 0 ? _a : undefined };
+        return this.httpClient.get(`${this.basePath}/${id}/references`, { params });
+    }
+    updateStatus(id, desiredStatus) {
+        return this.httpClient.put(`${this.basePath}/${id}/status`, { desiredStatus });
+    }
+    deleteOne(id) {
+        return this.updateStatus(id, 'deleted');
+    }
+    async waitForRunningStatus(id) {
+        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);
+                    event.data === 'running' ? resolve() : reject(`Deployment in failed status: ${event.data}`);
+                }
+            });
+        });
+    }
+    addOne(dto) {
+        return super.addOne(dto);
+    }
+    subscribeToStatus(id, listener, errorListener) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/status`, listener, errorListener);
+    }
+    subscribeToLogs(id, listener, errorListener) {
+        return this.httpClient.addEventSource(`${this.basePath}/${id}/logs/subscribe`, listener, errorListener);
+    }
+}
+exports.FlowDeploymentService = FlowDeploymentService;

package/dist/flow-function.interface.d.ts

@@ -0,0 +1,47 @@
+export interface FlowFunctionDto {
+    fqn: string;
+    category: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    author: string;
+    current: string;
+    history: string[] | HistoryEntry[];
+    name?: string;
+    description?: string;
+    icon?: string;
+    isAbstract?: boolean;
+    supertype?: string;
+    propertiesSchema?: Schema;
+    inputStreams?: Stream[];
+    outputStreams?: Stream[];
+    tags?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface HistoryEntry {
+    author: string;
+    createdAt: string;
+    id: string;
+}
+interface Stream {
+    name: string;
+}
+interface Schema {
+    schema: {
+        type: string;
+        properties?: {
+            [key: string]: SchemaProperty;
+        };
+    };
+    layout?: any[];
+    data?: any;
+}
+declare type SchemaPropertyType = 'array' | 'boolean' | 'number' | 'string';
+interface SchemaProperty {
+    type: SchemaPropertyType;
+    title?: string;
+    description?: string;
+    default?: any;
+    [key: string]: any;
+}
+export {};

package/dist/flow-function.interface.js

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

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

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

package/dist/flow-function.service.js

@@ -0,0 +1,20 @@
+"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 {
+    constructor(httpClient) {
+        super(httpClient, '/flow/functions');
+    }
+    addMany(dto) {
+        const reqs = dto.map((v) => this.addOne(v));
+        return Promise.all(reqs);
+    }
+    getOneWithHistory(fqn) {
+        return this.httpClient.get(`${this.basePath}/${fqn}/history`);
+    }
+    rollback(fqn, historyId) {
+        return this.httpClient.put(`${this.basePath}/${fqn}/rollback/${historyId}`, {});
+    }
+}
+exports.FlowFunctionService = FlowFunctionService;

package/dist/flow-module.interface.d.ts

@@ -0,0 +1,13 @@
+import { Artifact } from './storage.interface';
+export interface FlowModule {
+    name: string;
+    description?: string;
+    artifacts: Artifact[];
+    author: string;
+    tags?: string[];
+    functions: string[];
+    readPermissions: string[];
+    readWritePermissions: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}

package/dist/flow-module.interface.js

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

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { DataService } from './data.service';
+import { FlowModule } from './flow-module.interface';
+import { HttpClient } from './http.service';
+import { ReadStream } from 'fs';
+export declare class FlowModuleService extends DataService<FlowModule> {
+    constructor(httpClient: HttpClient);
+    deleteArtifact(name: string, version: string): Promise<FlowModule>;
+    download(name: string, filePath: string, version?: string): Promise<void>;
+    publish(file: ReadStream): Promise<unknown>;
+    addOne(dto: any): Promise<FlowModule>;
+    addMany(dto: any[]): Promise<FlowModule[]>;
+}

package/dist/flow-module.service.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowModuleService = void 0;
+const tslib_1 = require("tslib");
+const data_service_1 = require("./data.service");
+const fs_1 = require("fs");
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
+const promises_1 = require("stream/promises");
+class FlowModuleService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flow/modules');
+    }
+    deleteArtifact(name, version) {
+        return this.httpClient.delete(`${this.basePath}/${name}/${version}`);
+    }
+    async download(name, filePath, version = 'latest') {
+        const writer = (0, fs_1.createWriteStream)(filePath);
+        return this.httpClient.get(`${this.basePath}/${name}/${version}`, { responseType: 'stream' }).then(async (response) => {
+            response.pipe(writer);
+            return (0, promises_1.finished)(writer);
+        });
+    }
+    publish(file) {
+        const form = new form_data_1.default();
+        form.append('file', file);
+        const config = {
+            headers: Object.assign({}, form.getHeaders()),
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+        };
+        return this.httpClient.post(`${this.basePath}`, form, config);
+    }
+    addOne(dto) {
+        throw new Error('not allowed: use publish instead');
+    }
+    addMany(dto) {
+        throw new Error('not allowed: use publish instead');
+    }
+}
+exports.FlowModuleService = FlowModuleService;

package/dist/flow.interface.d.ts

@@ -0,0 +1,25 @@
+import { Resource } from './resource.interface';
+import { JsonSchemaForm } from './schema.interface';
+import { FlowDeployment } from './flow-deployment.interface';
+export interface FlowDto extends Resource {
+    diagram: string | FlowDiagram;
+    deployments?: string[] | FlowDeployment[];
+    dashboard?: DashboardItem[];
+    propertiesSchema?: JsonSchemaForm;
+}
+export interface DashboardItem {
+    id: string;
+    cols: number;
+    rows: number;
+    x: number;
+    y: number;
+}
+export interface FlowDiagram {
+    id: string;
+    flow: string | FlowDto;
+    json: string;
+    author: string;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+    deleteddAt?: Date | string;
+}

package/dist/flow.interface.js

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

package/dist/flow.service.d.ts

@@ -0,0 +1,11 @@
+import { DataService } from './data.service';
+import { FlowDto } from './flow.interface';
+import { HttpClient } from './http.service';
+import { Paginated, RequestParameter } from './data.interface';
+export declare class FlowService extends DataService<FlowDto> {
+    constructor(httpClient: HttpClient);
+    addMany(dto: any[]): Promise<FlowDto[]>;
+    getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
+    getOne(id: string, options?: any): Promise<FlowDto>;
+    getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
+}

package/dist/flow.service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowService = void 0;
+const data_service_1 = require("./data.service");
+class FlowService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, '/flows');
+    }
+    addMany(dto) {
+        const reqs = dto.map((v) => this.addOne(v));
+        return Promise.all(reqs);
+    }
+    getMany(params = {}) {
+        params.populate = params.populate ? params.populate : 'none';
+        return super.getMany(params);
+    }
+    getOne(id, options = {}) {
+        options.populate = options.populate ? options.populate : 'none';
+        return super.getOne(id, options);
+    }
+    getFlowWithDiagram(diagramId) {
+        return this.httpClient.get(`${this.basePath}/diagram/${diagramId}`);
+    }
+}
+exports.FlowService = FlowService;

package/dist/http.service.d.ts

@@ -1,5 +1,7 @@
 import { AxiosRequestConfig } from 'axios';
+import EventSource from 'eventsource';
 export declare class HttpClient {
+    private baseURL;
     private readonly realm;
     private readonly client;
     private readonly secret;
@@ -8,6 +10,7 @@ export declare class HttpClient {
     private readonly requestQueue;
     private accessToken;
     private accessTokenExpiration;
+    eventSourcesMap: Map<string, EventSource>;
     constructor(baseURL: string, authbaseURL: string, realm: string, client: string, secret: string);
     getQueueStats: () => {
         peak: number;
@@ -20,6 +23,9 @@ export declare class HttpClient {
     post: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
     put: <T>(url: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
     private request;
+    addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    destroyEventSource(id: string): void;
+    destroyAllEventSources(): void;
     getAccessToken: () => Promise<string>;
     private isTokenValid;
     private getToken;

package/dist/http.service.js

@@ -2,15 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
 const tslib_1 = require("tslib");
-const axios_1 = (0, tslib_1.__importDefault)(require("axios"));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const eventsource_1 = tslib_1.__importDefault(require("eventsource"));
 const Queue_1 = require("./Queue");
+const crypto_1 = require("crypto");
 const EXPIRATION_BUFFER = 30 * 1000;
 class HttpClient {
     constructor(baseURL, authbaseURL, realm, client, secret) {
+        this.baseURL = baseURL;
         this.realm = realm;
         this.client = client;
         this.secret = secret;
         this.accessTokenExpiration = 0;
+        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);
         this.get = (url, config) => this.request('GET', url, config);
@@ -69,5 +73,34 @@ class HttpClient {
         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 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);
+        return id;
+    }
+    destroyEventSource(id) {
+        if (!this.eventSourcesMap.has(id)) {
+            return;
+        }
+        const es = this.eventSourcesMap.get(id);
+        es.close();
+        es.removeEventListener('message', () => { });
+        es.removeEventListener('error', () => { });
+        this.eventSourcesMap.delete(id);
+    }
+    destroyAllEventSources() {
+        for (const key of this.eventSourcesMap.keys()) {
+            this.destroyEventSource(key);
+        }
+    }
 }
 exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -10,4 +10,9 @@ export * from './timeseries.interface';
 export * from './task.interface';
 export * from './events.interface';
 export * from './mock';
+export * from './flow-deployment.interface';
+export * from './flow-function.interface';
+export * from './flow.interface';
+export * from './resource.interface';
+export * from './schema.interface';
 export * as SiDrive from './sidriveiq.interface';

package/dist/index.js

@@ -2,16 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiDrive = void 0;
 const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./api"), exports);
-(0, tslib_1.__exportStar)(require("./asset.interface"), exports);
-(0, tslib_1.__exportStar)(require("./content.interface"), exports);
-(0, tslib_1.__exportStar)(require("./data.interface"), exports);
-(0, tslib_1.__exportStar)(require("./data.service"), exports);
-(0, tslib_1.__exportStar)(require("./endpoint.interface"), exports);
-(0, tslib_1.__exportStar)(require("./http.service"), exports);
-(0, tslib_1.__exportStar)(require("./secret.interface"), exports);
-(0, tslib_1.__exportStar)(require("./timeseries.interface"), exports);
-(0, tslib_1.__exportStar)(require("./task.interface"), exports);
-(0, tslib_1.__exportStar)(require("./events.interface"), exports);
-(0, tslib_1.__exportStar)(require("./mock"), exports);
-exports.SiDrive = (0, tslib_1.__importStar)(require("./sidriveiq.interface"));
+tslib_1.__exportStar(require("./api"), exports);
+tslib_1.__exportStar(require("./asset.interface"), exports);
+tslib_1.__exportStar(require("./content.interface"), exports);
+tslib_1.__exportStar(require("./data.interface"), exports);
+tslib_1.__exportStar(require("./data.service"), exports);
+tslib_1.__exportStar(require("./endpoint.interface"), exports);
+tslib_1.__exportStar(require("./http.service"), exports);
+tslib_1.__exportStar(require("./secret.interface"), exports);
+tslib_1.__exportStar(require("./timeseries.interface"), exports);
+tslib_1.__exportStar(require("./task.interface"), exports);
+tslib_1.__exportStar(require("./events.interface"), exports);
+tslib_1.__exportStar(require("./mock"), exports);
+tslib_1.__exportStar(require("./flow-deployment.interface"), exports);
+tslib_1.__exportStar(require("./flow-function.interface"), exports);
+tslib_1.__exportStar(require("./flow.interface"), exports);
+tslib_1.__exportStar(require("./resource.interface"), exports);
+tslib_1.__exportStar(require("./schema.interface"), exports);
+exports.SiDrive = tslib_1.__importStar(require("./sidriveiq.interface"));

package/dist/mock/api.mock.d.ts

@@ -15,6 +15,15 @@ import { Task } from '../task.interface';
 import { TimeseriesMockService } from './timeseries.mock.service';
 import { TaskMockService } from './task.mock.service';
 import { UserMockService } from './user.mock.service';
+import { FlowDeploymentService } from '../flow-deployment.service';
+import { FlowFunctionService } from '../flow-function.service';
+import { FlowModuleService } from '../flow-module.service';
+import { FlowService } from '../flow.service';
+import { FlowDiagram, FlowDto } from '../flow.interface';
+import { FlowDeployment } from '../flow-deployment.interface';
+import { FlowFunctionDto } from '../flow-function.interface';
+import { FlowModule } from '../flow-module.interface';
+import { Artifact } from '../storage.interface';
 export declare class MockAPI implements API {
     httpClient: any;
     assets: AssetMockService;
@@ -22,6 +31,10 @@ export declare class MockAPI implements API {
     contents: ContentMockService;
     endpoints: EndpointMockService;
     events: EventsMockService;
+    flows: FlowService;
+    flowDeployments: FlowDeploymentService;
+    flowFunctions: FlowFunctionService;
+    flowModules: FlowModuleService;
     proxy: any;
     secrets: SecretMockService;
     tasks: TaskMockService;
@@ -46,6 +59,11 @@ export declare class MockAPI implements API {
         tasks?: TaskInit[];
         events?: EventInit[];
         users?: UserInit;
+        flows?: FlowInit[];
+        deployments?: FlowDeploymentInit[];
+        functions?: FlowFunctionInit[];
+        modules?: FlowModuleInit[];
+        diagrams?: FlowDiagramInit[];
     });
 }
 export declare type Identity<T> = {
@@ -69,6 +87,16 @@ export declare type TimeSeriesInit = Identity<AtLeast<TimeSeries, 'id' | 'name'>
 }>;
 export declare type TaskInit = AtLeast<Task, 'name' | 'assignedTo'>;
 export declare type EventInit = AtLeast<Event, 'name'>;
+export declare type FlowInit = AtLeast<FlowDto, 'id'>;
+export declare type FlowDeploymentInit = AtLeast<FlowDeployment, 'id' | 'flow'>;
+export declare type FlowFunctionInit = AtLeast<Identity<FlowFunctionDto & {
+    id: string;
+}>, 'fqn' | 'id'>;
+export declare type FlowModuleInit = Replace<AtLeast<FlowModule, 'name'>, 'artifacts', ArtifactInit[]>;
+export declare type ArtifactInit = AtLeast<Artifact & {
+    path: string;
+}, 'filename' | 'path'>;
+export declare type FlowDiagramInit = AtLeast<FlowDiagram, 'id' | 'flow'>;
 export interface UserInit {
     roles: string[];
 }

package/dist/mock/api.mock.js

@@ -11,12 +11,17 @@ const secret_mock_service_1 = require("./secret.mock.service");
 const timeseries_mock_service_1 = require("./timeseries.mock.service");
 const task_mock_service_1 = require("./task.mock.service");
 const user_mock_service_1 = require("./user.mock.service");
+const flow_mock_service_1 = require("./flow.mock.service");
+const flow_deployment_mock_service_1 = require("./flow-deployment.mock.service");
+const flow_functions_mock_service_1 = require("./flow-functions.mock.service");
+const flow_modules_mock_service_1 = require("./flow-modules.mock.service");
+const crypto_1 = require("crypto");
 class MockAPI {
     constructor(initData) {
         this.httpClient = null;
         this.proxy = null;
         this.siDrive = null;
-        const { assets = [], revisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, } = initData;
+        const { assets = [], revisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, flows = [], deployments = [], functions = [], modules = [], diagrams = [], } = initData;
         const assetTypes = assets
             .map((v) => v.type)
             .map((v) => {
@@ -91,6 +96,31 @@ class MockAPI {
             group: v.group,
         }));
         const timeseriesValues = timeSeries.map((v) => v.values);
+        const diagrams1 = diagrams.map((v) => (Object.assign(Object.assign({}, v), { json: '', author: 'nobody' })));
+        const flows1 = flows.map((v) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], diagram: diagrams.find((v1) => v1.flow === v.id).id, name: `flow-${v.id}`, deployments: [] })));
+        const deployments1 = deployments.map((v) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], diagram: (_a = v.diagram) !== null && _a !== void 0 ? _a : '', artifact: null, flowModel: { connections: [], elements: [] }, desiredStatus: 'running', actualStatus: 'generating queued', target: 'executor', name: `deployment-${v.id}` }));
+        });
+        const functions1 = functions.map((v) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { category: 'task', readPermissions: [], readWritePermissions: [], author: 'nobody', current: v.id, history: [v.id, ...((_a = v === null || v === void 0 ? void 0 : v.history) !== null && _a !== void 0 ? _a : [])] }));
+        });
+        const historyMap = new Map();
+        functions1.forEach((func) => {
+            func.history.forEach((hist) => {
+                if (historyMap.has(func.fqn)) {
+                    historyMap.get(func.fqn).push(functions1.find((v) => v.id === hist));
+                }
+                else {
+                    historyMap.set(func.fqn, [functions1.find((v) => v.id === hist)]);
+                }
+            });
+        });
+        const modules1 = modules.map((v, index) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { artifacts: (_a = modules[index].artifacts.map((art) => (Object.assign(Object.assign({}, art), { version: '0.0.0', id: (0, crypto_1.randomUUID)(), mimetype: '', size: 0, createdAt: '' + Date.now() })))) !== null && _a !== void 0 ? _a : [], author: 'nobody', functions: [], readPermissions: [], readWritePermissions: [] }));
+        });
         this.assets = new asset_mock_service_1.AssetMockService(this, assets1, revisions1);
         this.contents = new content_mock_service_1.ContentMockService(contents1, contentData);
         this.endpoints = new endpoint_mock_service_1.EndpointMockService(endpoint1);
@@ -99,6 +129,10 @@ class MockAPI {
         this.tasks = new task_mock_service_1.TaskMockService(tasks1);
         this.events = new events_mock_service_1.EventsMockService(events1);
         this.users = new user_mock_service_1.UserMockService(users);
+        this.flows = new flow_mock_service_1.FlowMockService(flows1, diagrams1);
+        this.flowDeployments = new flow_deployment_mock_service_1.FlowDeploymentMockService(deployments1, this);
+        this.flowFunctions = new flow_functions_mock_service_1.FlowFunctionsMockService(functions1, historyMap);
+        this.flowModules = new flow_modules_mock_service_1.FlowModulesMockService(modules1);
         this.assetManager = this.assets;
         this.contentManager = this.contents;
         this.endpointManager = this.endpoints;

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

@@ -0,0 +1,27 @@
+import { DataMockService } from './data.mock.service';
+import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from '../flow-deployment.interface';
+import { FlowDeploymentService } from '../flow-deployment.service';
+import { ResourceReference } from '../resource.interface';
+import { MockAPI } from './api.mock';
+export declare class FlowDeploymentMockService extends DataMockService<FlowDeployment> 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>;
+    resolveReferences(id: string, recursive?: boolean, types?: string[]): Promise<ResourceReference[]>;
+    getDeploymentStatistics(id: string): Promise<FlowDeploymentStatistic>;
+    getDeploymentMetrics(id: string, range?: string, interval?: string): Promise<FlowDeploymentMetrics>;
+    getDeploymentLogs(id: string): Promise<FlowLog[]>;
+    addOne(dto: {
+        diagramId: string;
+        name: string;
+        properties?: Record<string, any>;
+        readPermissions?: string[];
+        readWritePermissions?: string[];
+        tags?: string[];
+    }): Promise<FlowDeployment>;
+    deleteOne(id: string): Promise<FlowDeployment>;
+    private getReferences;
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowDeploymentMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
+class FlowDeploymentMockService extends data_mock_service_1.DataMockService {
+    constructor(deployments, api) {
+        super();
+        this.api = api;
+        this.data = deployments;
+    }
+    subscribeToStatus(id, listener, errorListener) {
+        listener(new MessageEvent('message', { data: 'running' }));
+        return Promise.resolve((0, crypto_1.randomUUID)());
+    }
+    subscribeToLogs(id, listener, errorListener) {
+        listener(new MessageEvent('message', { data: 'foo' }));
+        return Promise.resolve((0, crypto_1.randomUUID)());
+    }
+    async waitForRunningStatus(id) {
+        const flowDeployment = this.data.find((v) => v.id === id);
+        flowDeployment.actualStatus = 'running';
+    }
+    async updateStatus(id, desiredStatus) {
+        const deployment = await this.getOne(id);
+        deployment.desiredStatus = desiredStatus;
+        deployment.actualStatus = desiredStatus;
+        return Promise.resolve(deployment);
+    }
+    async resolveReferences(id, recursive, types) {
+        var _a;
+        const depl = await this.getOne(id);
+        return (_a = depl.refs) !== null && _a !== void 0 ? _a : [];
+    }
+    getDeploymentStatistics(id) {
+        return Promise.resolve({
+            totalErrorCount: 0,
+            errorCountWeek: 0,
+            eventCountWeek: 0,
+            errorCounts: [],
+            metrics: {
+                cpu: 0,
+                memory: 97931264,
+                ctime: 16770,
+                elapsed: 172850950,
+                timestamp: 1648199692625,
+                deploymentId: id,
+            },
+        });
+    }
+    getDeploymentMetrics(id, range, interval) {
+        return Promise.resolve({
+            metrics: [{ timestamp: Date.now(), cpu: 0, memory: Math.random() * 1000000 }],
+            stats: {
+                cpu: { count: 123, avg: 0, max: 0, min: 0, sum: 0 },
+                memory: { count: 123, avg: 0, max: 0, min: 0, sum: 0 },
+            },
+        });
+    }
+    async getDeploymentLogs(id) {
+        const depl = await this.getOne(id);
+        return Promise.resolve([
+            {
+                type: 'flow.log.info',
+                deploymentId: id,
+                subject: 'FlowApplication',
+                data: 'Flow Deployment is running',
+                '@timestamp': '2022-03-23T09:14:03.129Z',
+                eventId: 'c68b7674-b8da-46c5-85f0-8e4279d74a78',
+                datacontenttype: 'text/plain',
+                elementId: 'none',
+                time: '2022-03-23T09:14:03.129Z',
+                flowId: depl.flow,
+            },
+        ]);
+    }
+    async addOne(dto) {
+        const flow = await this.api.flows.getFlowWithDiagram(dto.diagramId);
+        const refs = await this.getReferences(dto.properties);
+        const id = (0, crypto_1.randomUUID)();
+        const newDepl = {
+            actualStatus: 'generating queued',
+            artifact: undefined,
+            desiredStatus: 'running',
+            diagram: dto.diagramId,
+            flow: flow.id,
+            flowModel: { elements: [], connections: [], properties: dto.properties },
+            id,
+            name: dto.name,
+            readPermissions: [],
+            readWritePermissions: [],
+            target: 'executor',
+            refs,
+        };
+        await this.api.flows.updateOne(flow.id, Object.assign(Object.assign({}, flow), { deployments: [...flow.deployments, id] }));
+        return super.addOne(newDepl);
+    }
+    async deleteOne(id) {
+        const depl = await this.getOne(id);
+        const flow = await this.api.flows.getOne(depl.flow);
+        const index = flow.deployments.findIndex((v) => v === id);
+        flow.deployments.splice(index, 1);
+        await this.api.flows.updateOne(flow.id, flow);
+        return super.deleteOne(id);
+    }
+    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');
+            }
+        }));
+    }
+}
+exports.FlowDeploymentMockService = FlowDeploymentMockService;

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

@@ -0,0 +1,14 @@
+import { DataMockService } from './data.mock.service';
+import { FlowFunctionDto } from '../flow-function.interface';
+import { FlowFunctionService } from '../flow-function.service';
+export declare class FlowFunctionsMockService extends DataMockService<FlowFunctionDto> implements FlowFunctionService {
+    private history;
+    constructor(functions: FlowFunctionDto[], history: Map<string, Array<FlowFunctionDto & {
+        id: string;
+    }>>);
+    getOneWithHistory(fqn: string): Promise<FlowFunctionDto>;
+    rollback(fqn: string, historyId: string): Promise<FlowFunctionDto>;
+    getOne(fqn: string, options?: any): Promise<FlowFunctionDto>;
+    private getOneById;
+    updateOne(fqn: string, dto: FlowFunctionDto): Promise<FlowFunctionDto>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowFunctionsMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
+class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
+    constructor(functions, history) {
+        super();
+        this.history = history;
+        this.data = functions;
+    }
+    async getOneWithHistory(fqn) {
+        const func = await this.getOne(fqn);
+        return Promise.resolve(Object.assign(Object.assign({}, func), { history: await Promise.all(func.history.map(async (v) => {
+                const func1 = (await this.getOneById(v));
+                return { author: func1.author, createdAt: '', id: func1.id };
+            })) }));
+    }
+    rollback(fqn, historyId) {
+        const hist = this.history.get(fqn).find((v) => v.id === historyId);
+        const index = this.data.findIndex((v) => v.fqn === fqn);
+        hist.current = hist.id;
+        this.data[index] = hist;
+        return Promise.resolve(hist);
+    }
+    getOne(fqn, options) {
+        const t = this.data.find((v) => v.fqn === fqn);
+        return Promise.resolve(t);
+    }
+    async getOneById(id) {
+        return this.data.find((v) => v.id === id);
+    }
+    async updateOne(fqn, dto) {
+        const id = (0, crypto_1.randomUUID)();
+        const exDto = Object.assign(Object.assign({}, dto), { id, current: id });
+        exDto.history.push(id);
+        this.history.get(fqn).push(exDto);
+        return exDto;
+    }
+}
+exports.FlowFunctionsMockService = FlowFunctionsMockService;

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { DataMockService } from './data.mock.service';
+import { FlowModule } from '../flow-module.interface';
+import { FlowModuleService } from '../flow-module.service';
+import { ReadStream } from 'fs';
+import { Artifact } from '../storage.interface';
+import { Replace } from './api.mock';
+declare type ExtendedFlowModule = Replace<FlowModule, 'artifacts', Array<Artifact & {
+    path: string;
+}>>;
+export declare class FlowModulesMockService extends DataMockService<ExtendedFlowModule> implements FlowModuleService {
+    constructor(modules: ExtendedFlowModule[]);
+    deleteArtifact(name: string, version: string): Promise<FlowModule>;
+    download(name: string, filePath: string, version?: string): Promise<void>;
+    publish(file: ReadStream): Promise<unknown>;
+    getOne(name: string, options?: any): Promise<ExtendedFlowModule>;
+}
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowModulesMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+const fs_1 = require("fs");
+const promises_1 = require("stream/promises");
+class FlowModulesMockService extends data_mock_service_1.DataMockService {
+    constructor(modules) {
+        super();
+        this.data = modules;
+    }
+    async deleteArtifact(name, version) {
+        const module = await this.getOne(name);
+        const index = module.artifacts.findIndex((art) => art.version === version);
+        module.artifacts.splice(index, 1);
+        return Promise.resolve(module);
+    }
+    async download(name, filePath, version = 'latest') {
+        var _a, _b;
+        const module = await this.getOne(name);
+        const reader = (0, fs_1.createReadStream)((_b = (_a = module.artifacts.find((art) => art.version === version)) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : module.artifacts[0].path);
+        const writer = (0, fs_1.createWriteStream)(filePath);
+        reader.pipe(writer);
+        return (0, promises_1.finished)(writer);
+    }
+    publish(file) {
+        return Promise.resolve(undefined);
+    }
+    getOne(name, options = {}) {
+        const t = this.data.find((v) => v.name === name);
+        return Promise.resolve(t);
+    }
+}
+exports.FlowModulesMockService = FlowModulesMockService;

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

@@ -0,0 +1,10 @@
+import { DataMockService } from './data.mock.service';
+import { FlowDiagram, FlowDto } from '../flow.interface';
+import { FlowService } from '../flow.service';
+import { Paginated, RequestParameter } from '../data.interface';
+export declare class FlowMockService extends DataMockService<FlowDto> implements FlowService {
+    private diagrams;
+    constructor(flows: FlowDto[], diagrams: FlowDiagram[]);
+    getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
+    getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class FlowMockService extends data_mock_service_1.DataMockService {
+    constructor(flows, diagrams) {
+        super();
+        this.diagrams = diagrams;
+        this.data = flows;
+    }
+    getFlowWithDiagram(diagramId) {
+        return Promise.resolve(this.data.find((v1) => v1.id === this.diagrams.find((v) => v.id === diagramId).flow));
+    }
+    async getMany(params) {
+        const flows = await super.getMany(params);
+        return {
+            docs: flows.docs.map((v) => (Object.assign(Object.assign({}, v), { diagram: this.diagrams.find((v1) => v1.id === v.diagram) }))),
+            total: 0,
+            limit: 0,
+        };
+    }
+}
+exports.FlowMockService = FlowMockService;

package/dist/mock/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./api.mock"), exports);
-(0, tslib_1.__exportStar)(require("./asset.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./assetTypes.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./content.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./data.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./secret.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./timeseries.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./task.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./events.mock.service"), exports);
+tslib_1.__exportStar(require("./api.mock"), exports);
+tslib_1.__exportStar(require("./asset.mock.service"), exports);
+tslib_1.__exportStar(require("./assetTypes.mock.service"), exports);
+tslib_1.__exportStar(require("./content.mock.service"), exports);
+tslib_1.__exportStar(require("./data.mock.service"), exports);
+tslib_1.__exportStar(require("./secret.mock.service"), exports);
+tslib_1.__exportStar(require("./timeseries.mock.service"), exports);
+tslib_1.__exportStar(require("./task.mock.service"), exports);
+tslib_1.__exportStar(require("./events.mock.service"), exports);

package/dist/resource.interface.d.ts

@@ -0,0 +1,18 @@
+export interface ResourceReference {
+    id: string;
+    resourceType: string;
+    dependent?: boolean;
+}
+export interface Resource {
+    id: string;
+    name: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    description?: string;
+    author?: string;
+    tags?: string[];
+    refs?: ResourceReference[];
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+    deleteddAt?: string | Date;
+}

package/dist/resource.interface.js

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

package/dist/schema.interface.d.ts

@@ -0,0 +1,18 @@
+export interface JsonSchemaForm {
+    schema: JsonSchema;
+    layout: Record<string, any> | Record<string, any>[];
+}
+export declare type JsonSchemaTypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+export declare type JsonSchemaType = string | number | boolean | {
+    [key: string]: JsonSchemaType;
+} | JsonSchemaArray | null;
+export declare type JsonSchemaArray = Array<JsonSchemaType>;
+export interface JsonSchema {
+    default?: JsonSchemaType;
+    description?: string;
+    items?: JsonSchema | JsonSchema[];
+    properties?: Record<string, JsonSchema>;
+    required?: boolean | string[];
+    title?: string;
+    type?: JsonSchemaTypeName | JsonSchemaTypeName[];
+}

package/dist/schema.interface.js

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

package/dist/storage.interface.d.ts

@@ -0,0 +1,16 @@
+export declare type FileType = 'original' | 'preview-sm' | 'preview-md' | 'preview-lg' | 'preview-xl';
+export declare type StorageProvider = 's3' | 'mongo';
+export interface Storage {
+    id: string;
+    filename: string;
+    mimetype: string;
+    size: number;
+    createdAt: string;
+    provider?: StorageProvider;
+    type?: FileType;
+    md5?: string;
+}
+export interface Artifact extends Storage {
+    version: string;
+    functions?: string[];
+}

package/dist/storage.interface.js

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

package/dist/user.service.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserService = void 0;
 const tslib_1 = require("tslib");
-const jwt_decode_1 = (0, tslib_1.__importDefault)(require("jwt-decode"));
+const jwt_decode_1 = tslib_1.__importDefault(require("jwt-decode"));
 class UserService {
     constructor(httpClient) {
         this.httpClient = httpClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Module for easy access to the HahnPRO API",
   "license": "MIT",
   "author": {
@@ -24,13 +24,15 @@
     "access": "public"
   },
   "dependencies": {
-    "axios": "^0.25.0",
+    "axios": "^0.26.1",
+    "eventsource": "^2.0.0",
     "form-data": "^4.0.0",
     "jwt-decode": "^3.1.2",
     "p-queue": "^6.6.2"
   },
   "devDependencies": {
-    "axios-mock-adapter": "^1.20.0"
+    "axios-mock-adapter": "^1.20.0",
+    "@types/eventsource": "^1.1.8"
   },
   "engines": {
     "node": ">=v14.13"