@pulze-io/renderflow 1.2.1

package/dist/index.js

@@ -0,0 +1,812 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EventListener: () => EventListener,
+  RenderFlow: () => RenderFlow
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios2 = __toESM(require("axios"));
+
+// src/api.ts
+var import_axios = __toESM(require("axios"));
+var HttpClient = class {
+  constructor({
+    securityWorker,
+    secure,
+    format,
+    ...axiosConfig
+  } = {}) {
+    this.securityData = null;
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.request = async ({
+      secure,
+      path,
+      type,
+      query,
+      format,
+      body,
+      ...params
+    }) => {
+      const secureParams = (typeof secure === "boolean" ? secure : this.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const responseFormat = format || this.format || void 0;
+      if (type === "multipart/form-data" /* FormData */ && body && body !== null && typeof body === "object") {
+        body = this.createFormData(body);
+      }
+      if (type === "text/plain" /* Text */ && body && body !== null && typeof body !== "string") {
+        body = JSON.stringify(body);
+      }
+      return this.instance.request({
+        ...requestParams,
+        headers: {
+          ...requestParams.headers || {},
+          ...type ? { "Content-Type": type } : {}
+        },
+        params: query,
+        responseType: responseFormat,
+        data: body,
+        url: path
+      }).then((response) => response.data);
+    };
+    this.instance = import_axios.default.create({
+      ...axiosConfig,
+      baseURL: axiosConfig.baseURL || "/api/v1"
+    });
+    this.secure = secure;
+    this.format = format;
+    this.securityWorker = securityWorker;
+  }
+  mergeRequestParams(params1, params2) {
+    const method = params1.method || params2 && params2.method;
+    return {
+      ...this.instance.defaults,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...method && this.instance.defaults.headers[method.toLowerCase()] || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  stringifyFormItem(formItem) {
+    if (typeof formItem === "object" && formItem !== null) {
+      return JSON.stringify(formItem);
+    } else {
+      return `${formItem}`;
+    }
+  }
+  createFormData(input) {
+    if (input instanceof FormData) {
+      return input;
+    }
+    return Object.keys(input || {}).reduce((formData, key) => {
+      const property = input[key];
+      const propertyContent = property instanceof Array ? property : [property];
+      for (const formItem of propertyContent) {
+        const isFileType = formItem instanceof Blob || formItem instanceof File;
+        formData.append(
+          key,
+          isFileType ? formItem : this.stringifyFormItem(formItem)
+        );
+      }
+      return formData;
+    }, new FormData());
+  }
+};
+var Api = class {
+  constructor(http) {
+    this.users = {
+      /**
+       * @description Get all users
+       *
+       * @tags Users
+       * @name GetUsers
+       * @request GET:/users
+       * @secure
+       */
+      getUsers: (params = {}) => this.http.request({
+        path: `/users`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get a specific user by id
+       *
+       * @tags Users
+       * @name GetUser
+       * @request GET:/users/{id}
+       * @secure
+       */
+      getUser: (id, params = {}) => this.http.request({
+        path: `/users/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+    this.tasks = {
+      /**
+       * @description Get tasks for a specific job
+       *
+       * @tags Tasks
+       * @name GetTasks
+       * @request GET:/tasks
+       * @secure
+       */
+      getTasks: (query, params = {}) => this.http.request({
+        path: `/tasks`,
+        method: "GET",
+        query,
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Receive update stream from tasks
+       *
+       * @tags Tasks
+       * @name GetTaskEvents
+       * @request GET:/tasks/events/{job_id}
+       * @secure
+       */
+      getTaskEvents: (jobId, params = {}) => this.http.request({
+        path: `/tasks/events/${jobId}`,
+        method: "GET",
+        secure: true,
+        ...params
+      }),
+      /**
+       * @description Get task logs
+       *
+       * @tags Tasks
+       * @name GetTaskLogs
+       * @request GET:/tasks/{id}/logs
+       * @secure
+       */
+      getTaskLogs: (id, query, params = {}) => this.http.request({
+        path: `/tasks/${id}/logs`,
+        method: "GET",
+        query,
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Stream task logs via SSE
+       *
+       * @tags Tasks
+       * @name StreamTaskLogs
+       * @request GET:/tasks/{id}/logs/stream
+       * @secure
+       */
+      streamTaskLogs: (id, params = {}) => this.http.request({
+        path: `/tasks/${id}/logs/stream`,
+        method: "GET",
+        secure: true,
+        ...params
+      }),
+      /**
+       * @description Get task thumbnail
+       *
+       * @tags Tasks
+       * @name GetThumbnail
+       * @request GET:/tasks/{id}/thumbnail
+       * @secure
+       */
+      getThumbnail: (id, params = {}) => this.http.request({
+        path: `/tasks/${id}/thumbnail`,
+        method: "GET",
+        secure: true,
+        ...params
+      }),
+      /**
+       * @description Get a specific task by id
+       *
+       * @tags Tasks
+       * @name GetTask
+       * @request GET:/tasks/{id}
+       * @secure
+       */
+      getTask: (id, params = {}) => this.http.request({
+        path: `/tasks/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+    this.pools = {
+      /**
+       * @description Get all pools
+       *
+       * @tags Pools
+       * @name GetPools
+       * @request GET:/pools
+       * @secure
+       */
+      getPools: (params = {}) => this.http.request({
+        path: `/pools`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get a specific pool by id
+       *
+       * @tags Pools
+       * @name GetPool
+       * @request GET:/pools/{id}
+       * @secure
+       */
+      getPool: (id, params = {}) => this.http.request({
+        path: `/pools/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+    this.nodes = {
+      /**
+       * @description Get all nodes
+       *
+       * @tags Nodes
+       * @name GetNodes
+       * @request GET:/nodes
+       * @secure
+       */
+      getNodes: (params = {}) => this.http.request({
+        path: `/nodes`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get a specific node by id
+       *
+       * @tags Nodes
+       * @name GetNode
+       * @request GET:/nodes/{id}
+       * @secure
+       */
+      getNode: (id, params = {}) => this.http.request({
+        path: `/nodes/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Delete a node by id
+       *
+       * @tags Nodes
+       * @name DeleteNode
+       * @request DELETE:/nodes/{id}
+       * @secure
+       */
+      deleteNode: (id, params = {}) => this.http.request({
+        path: `/nodes/${id}`,
+        method: "DELETE",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Receive update stream from nodes
+       *
+       * @tags Nodes
+       * @name GetNodeEvents
+       * @request GET:/nodes/events
+       * @secure
+       */
+      getNodeEvents: (params = {}) => this.http.request({
+        path: `/nodes/events`,
+        method: "GET",
+        secure: true,
+        ...params
+      }),
+      /**
+       * @description Update the status of a node
+       *
+       * @tags Nodes
+       * @name UpdateStatus
+       * @request PATCH:/nodes/{id}/status
+       * @secure
+       */
+      updateStatus: (id, data, params = {}) => this.http.request({
+        path: `/nodes/${id}/status`,
+        method: "PATCH",
+        body: data,
+        secure: true,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get current hardware utilization for a node
+       *
+       * @tags Nodes
+       * @name GetNodeUtilization
+       * @request GET:/nodes/{id}/utilization
+       * @secure
+       */
+      getNodeUtilization: (id, params = {}) => this.http.request({
+        path: `/nodes/${id}/utilization`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Update the pool of a node
+       *
+       * @tags Nodes
+       * @name UpdateNodePool
+       * @request PATCH:/nodes/{id}/pool
+       * @secure
+       */
+      updateNodePool: (id, data, params = {}) => this.http.request({
+        path: `/nodes/${id}/pool`,
+        method: "PATCH",
+        body: data,
+        secure: true,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get node benchmark rankings
+       *
+       * @tags Nodes
+       * @name GetNodeBenchmarkRanking
+       * @request GET:/nodes/benchmarks/ranking
+       * @secure
+       */
+      getNodeBenchmarkRanking: (query, params = {}) => this.http.request({
+        path: `/nodes/benchmarks/ranking`,
+        method: "GET",
+        query,
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+    this.jobs = {
+      /**
+       * @description Receive update stream from jobs
+       *
+       * @tags Jobs
+       * @name GetJobEvents
+       * @request GET:/jobs/events
+       * @secure
+       */
+      getJobEvents: (params = {}) => this.http.request({
+        path: `/jobs/events`,
+        method: "GET",
+        secure: true,
+        ...params
+      }),
+      /**
+       * @description Get a specific job by id
+       *
+       * @tags Jobs
+       * @name GetJob
+       * @request GET:/jobs/{id}
+       * @secure
+       */
+      getJob: (id, params = {}) => this.http.request({
+        path: `/jobs/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Update a job
+       *
+       * @tags Jobs
+       * @name UpdateJob
+       * @request PATCH:/jobs/{id}
+       * @secure
+       */
+      updateJob: (id, data, params = {}) => this.http.request({
+        path: `/jobs/${id}`,
+        method: "PATCH",
+        body: data,
+        secure: true,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Delete a job
+       *
+       * @tags Jobs
+       * @name DeleteJob
+       * @request DELETE:/jobs/{id}
+       * @secure
+       */
+      deleteJob: (id, params = {}) => this.http.request({
+        path: `/jobs/${id}`,
+        method: "DELETE",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get all jobs
+       *
+       * @tags Jobs
+       * @name GetJobs
+       * @request GET:/jobs
+       * @secure
+       */
+      getJobs: (params = {}) => this.http.request({
+        path: `/jobs`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Create a new job
+       *
+       * @tags Jobs
+       * @name CreateJob
+       * @request POST:/jobs/create
+       */
+      createJob: (data, params = {}) => this.http.request({
+        path: `/jobs/create`,
+        method: "POST",
+        body: data,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Start a job
+       *
+       * @tags Jobs
+       * @name StartJob
+       * @request POST:/jobs/{id}/start
+       * @secure
+       */
+      startJob: (id, params = {}) => this.http.request({
+        path: `/jobs/${id}/start`,
+        method: "POST",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Stop a job
+       *
+       * @tags Jobs
+       * @name StopJob
+       * @request POST:/jobs/{id}/stop
+       * @secure
+       */
+      stopJob: (id, params = {}) => this.http.request({
+        path: `/jobs/${id}/stop`,
+        method: "POST",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Reset a job
+       *
+       * @tags Jobs
+       * @name ResetJob
+       * @request POST:/jobs/{id}/reset
+       * @secure
+       */
+      resetJob: (id, params = {}) => this.http.request({
+        path: `/jobs/${id}/reset`,
+        method: "POST",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Archive a job
+       *
+       * @tags Jobs
+       * @name ArchiveJob
+       * @request POST:/jobs/{id}/archive
+       * @secure
+       */
+      archiveJob: (id, params = {}) => this.http.request({
+        path: `/jobs/${id}/archive`,
+        method: "POST",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Update the pool of a job
+       *
+       * @tags Jobs
+       * @name UpdateJobPool
+       * @request PATCH:/jobs/{id}/pool
+       * @secure
+       */
+      updateJobPool: (id, data, params = {}) => this.http.request({
+        path: `/jobs/${id}/pool`,
+        method: "PATCH",
+        body: data,
+        secure: true,
+        type: "application/json" /* Json */,
+        format: "json",
+        ...params
+      })
+    };
+    this.info = {
+      /**
+       * @description Get information about the currently running RenderFlow instance
+       *
+       * @tags Info
+       * @name GetInfo
+       * @request GET:/info
+       * @secure
+       */
+      getInfo: (params = {}) => this.http.request({
+        path: `/info`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+    this.icons = {
+      /**
+       * @description Get job icon
+       *
+       * @tags Icons
+       * @name GetJobIcon
+       * @request GET:/icons/jobs/{type}
+       * @secure
+       */
+      getJobIcon: (type, params = {}) => this.http.request({
+        path: `/icons/jobs/${type}`,
+        method: "GET",
+        secure: true,
+        ...params
+      }),
+      /**
+       * @description Get software icon
+       *
+       * @tags Icons
+       * @name GetSoftwareIcon
+       * @request GET:/icons/software/{id}
+       * @secure
+       */
+      getSoftwareIcon: (id, params = {}) => this.http.request({
+        path: `/icons/software/${id}`,
+        method: "GET",
+        secure: true,
+        ...params
+      })
+    };
+    this.errors = {
+      /**
+       * @description Get all errors
+       *
+       * @tags Errors
+       * @name GetErrors
+       * @request GET:/errors
+       * @secure
+       */
+      getErrors: (params = {}) => this.http.request({
+        path: `/errors`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get errors by job id
+       *
+       * @tags Errors
+       * @name GetErrorsByJobId
+       * @request GET:/errors/job/{id}
+       * @secure
+       */
+      getErrorsByJobId: (id, params = {}) => this.http.request({
+        path: `/errors/job/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      }),
+      /**
+       * @description Get errors by node id
+       *
+       * @tags Errors
+       * @name GetErrorsByNodeId
+       * @request GET:/errors/node/{id}
+       * @secure
+       */
+      getErrorsByNodeId: (id, params = {}) => this.http.request({
+        path: `/errors/node/${id}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+        ...params
+      })
+    };
+    this.http = http;
+  }
+};
+
+// src/index.ts
+function parseEvent(raw) {
+  return {
+    type: raw.operationType,
+    document: raw.fullDocument ?? {},
+    updated: raw.updateDescription?.updatedFields,
+    time: raw.wallTime ?? 0
+  };
+}
+var EventListener = class {
+  constructor(url, headers, onEvent, onError) {
+    this._closed = false;
+    this._controller = new AbortController();
+    this._connect(url, headers, onEvent, onError);
+  }
+  async _connect(url, headers, onEvent, onError) {
+    try {
+      const response = await import_axios2.default.get(url, {
+        headers: { ...headers, Accept: "text/event-stream" },
+        responseType: "stream",
+        signal: this._controller.signal
+      });
+      let buffer = "";
+      response.data.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const parts = buffer.split("\n\n");
+        buffer = parts.pop() || "";
+        for (const part of parts) {
+          const line = part.trim();
+          if (!line || line.startsWith(":")) continue;
+          const dataPrefix = "data: ";
+          const dataLine = line.split("\n").find((l) => l.startsWith(dataPrefix));
+          if (!dataLine) continue;
+          try {
+            const raw = JSON.parse(dataLine.slice(dataPrefix.length));
+            onEvent(parseEvent(raw));
+          } catch {
+          }
+        }
+      });
+      response.data.on("error", (err) => {
+        if (!this._closed && onError) {
+          onError(err);
+        }
+      });
+    } catch (err) {
+      if (!this._closed && onError) {
+        onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }
+  close() {
+    this._closed = true;
+    this._controller.abort();
+  }
+};
+var RenderFlow = class {
+  constructor(options = {}) {
+    const { baseUrl = "http://localhost:44442/api/v1", apiKey, timeout = 3e4 } = options;
+    this._baseUrl = baseUrl;
+    this._headers = apiKey ? { "x-renderflow-api-key": apiKey } : {};
+    const httpClient = new HttpClient({
+      baseURL: baseUrl,
+      timeout,
+      headers: this._headers
+    });
+    const api = new Api(httpClient);
+    const self = this;
+    this.info = {
+      get: () => api.info.getInfo()
+    };
+    this.jobs = {
+      list: () => api.jobs.getJobs(),
+      get: (id) => api.jobs.getJob(id),
+      create: (data) => api.jobs.createJob(data),
+      update: (id, data) => api.jobs.updateJob(id, data),
+      delete: (id) => api.jobs.deleteJob(id),
+      start: (id) => api.jobs.startJob(id),
+      stop: (id) => api.jobs.stopJob(id),
+      reset: (id) => api.jobs.resetJob(id),
+      archive: (id) => api.jobs.archiveJob(id),
+      updatePool: (id, poolId) => api.jobs.updateJobPool(id, { poolId }),
+      on: (callback, onError) => {
+        return new EventListener(`${self._baseUrl}/jobs/events`, self._headers, callback, onError);
+      }
+    };
+    this.tasks = {
+      list: (jobId, page = 1, limit = 20) => api.tasks.getTasks({ jobId, pageInput: page, limit }),
+      get: (id) => api.tasks.getTask(id),
+      logs: (id, offset = 0, limit = 200) => api.tasks.getTaskLogs(id, { offset, limit }),
+      thumbnail: (id) => api.tasks.getThumbnail(id),
+      on: (jobId, callback, onError) => {
+        return new EventListener(`${self._baseUrl}/tasks/events/${jobId}`, self._headers, callback, onError);
+      }
+    };
+    this.nodes = {
+      list: () => api.nodes.getNodes(),
+      get: (id) => api.nodes.getNode(id),
+      delete: (id) => api.nodes.deleteNode(id),
+      updateStatus: (id, status) => api.nodes.updateStatus(id, { status }),
+      updatePool: (id, poolId) => api.nodes.updateNodePool(id, { poolId }),
+      utilization: (id) => api.nodes.getNodeUtilization(id),
+      benchmarks: (type) => api.nodes.getNodeBenchmarkRanking({ type }),
+      on: (callback, onError) => {
+        return new EventListener(`${self._baseUrl}/nodes/events`, self._headers, callback, onError);
+      }
+    };
+    this.pools = {
+      list: () => api.pools.getPools(),
+      get: (id) => api.pools.getPool(id)
+    };
+    this.users = {
+      list: () => api.users.getUsers(),
+      get: (id) => api.users.getUser(id)
+    };
+    this.errors = {
+      list: () => api.errors.getErrors(),
+      byJob: (id) => api.errors.getErrorsByJobId(id),
+      byNode: (id) => api.errors.getErrorsByNodeId(id)
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventListener,
+  RenderFlow
+});
+/**
+ * @title RenderFlow API Docs
+ * @version 1.0
+ * @license UNLICENSED
+ * @baseUrl /api/v1
+ * @contact Pulze
+ */