@unmeshed/sdk 1.0.6 → 1.0.7

package/dist/apiClient.d.ts

@@ -1,3 +1,14 @@
-import { AxiosInstance } from "axios";
-declare const _default: AxiosInstance;
-export default _default;
+import { ApiClientConfig, ApiResponse, ClientRequestConfig, QueryParams, RequestConfig } from "./types/index";
+export declare class ApiClient {
+    private axiosInstance;
+    private clientId;
+    initialize(config: ApiClientConfig): void;
+    private validateInstance;
+    private handleRequest;
+    private handleError;
+    get<T = any>(endpoint: string, params?: QueryParams, config?: RequestConfig): Promise<ApiResponse<T>>;
+    post<T = any>(endpoint: string, clientRequestConfig: ClientRequestConfig): Promise<ApiResponse<T>>;
+    put<T = any>(endpoint: string, clientRequestConfig: ClientRequestConfig): Promise<ApiResponse<T>>;
+    delete<T = any>(endpoint: string, clientRequestConfig: ClientRequestConfig): Promise<ApiResponse<T>>;
+    getClientId(): string | null;
+}

package/dist/apiClient.js

@@ -1,31 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
 const axios_1 = require("axios");
-const config_1 = require("./config");
+const unmeshedCommonUtils_1 = require("./utils/unmeshedCommonUtils");
 class ApiClient {
     constructor() {
-        const { hostname, port, bearerToken, basePath } = config_1.default.getConfig();
-        this.client = axios_1.default.create({
-            baseURL: `https://${hostname}:${port}${basePath || ""}`,
+        this.axiosInstance = null;
+        this.clientId = null;
+    }
+    initialize(config) {
+        const { clientId, authToken, baseUrl, port, timeout = 10000 } = config;
+        this.clientId = clientId;
+        if (!baseUrl) {
+            throw new Error("baseUrl is required");
+        }
+        const baseURL = port ? `${baseUrl}:${port}` : baseUrl;
+        this.axiosInstance = axios_1.default.create({
+            baseURL,
+            timeout,
             headers: {
-                Authorization: `Bearer ${bearerToken}`,
                 "Content-Type": "application/json",
+                Authorization: `Bearer client.sdk.${clientId}.${unmeshedCommonUtils_1.UnmeshedCommonUtils.createSecureHash(authToken)}`,
             },
         });
-        // Optional: Add interceptors for request/response
-        this.client.interceptors.request.use((req) => {
-            // Modify request if needed
-            return req;
-        }, (error) => {
-            return Promise.reject(error);
+    }
+    validateInstance() {
+        if (!this.axiosInstance) {
+            throw new Error("ApiClient must be initialized before making requests");
+        }
+    }
+    async handleRequest({ method, endpoint, params, data, config, }) {
+        this.validateInstance();
+        try {
+            const response = await this.axiosInstance.request({
+                method,
+                url: endpoint,
+                params,
+                data,
+                ...config,
+            });
+            return {
+                data: response.data,
+                status: response.status,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            console.error("Request failed:", error.message);
+            throw this.handleError(error);
+        }
+    }
+    handleError(error) {
+        var _a, _b;
+        console.error("Error details:", {
+            message: error.message,
+            status: (_a = error.response) === null || _a === void 0 ? void 0 : _a.status,
+            data: (_b = error.response) === null || _b === void 0 ? void 0 : _b.data,
+        });
+    }
+    async get(endpoint, params, config) {
+        return this.handleRequest({
+            method: "get",
+            endpoint: endpoint,
+            params: params,
+            config: config,
         });
-        this.client.interceptors.response.use((response) => response, (error) => {
-            // Handle errors globally
-            return Promise.reject(error);
+    }
+    async post(endpoint, clientRequestConfig) {
+        return this.handleRequest({
+            method: "post",
+            endpoint: endpoint,
+            ...clientRequestConfig,
+        });
+    }
+    async put(endpoint, clientRequestConfig) {
+        return this.handleRequest({
+            method: "put",
+            endpoint: endpoint,
+            ...clientRequestConfig,
+        });
+    }
+    async delete(endpoint, clientRequestConfig) {
+        return this.handleRequest({
+            method: "delete",
+            endpoint: endpoint,
+            ...clientRequestConfig,
         });
     }
-    getInstance() {
-        return this.client;
+    getClientId() {
+        return this.clientId;
     }
 }
-exports.default = new ApiClient().getInstance();
+exports.ApiClient = ApiClient;

package/dist/index.d.ts

@@ -1,4 +1,21 @@
-import { ApiConfig } from "./config";
-import * as TestApi from "./testApi";
-export declare const configure: (apiConfig: ApiConfig) => void;
-export declare const TestAPI: typeof TestApi;
+import { ApiClient } from "./apiClient";
+import pollForWorkers from "./poller/pollerClientImpl";
+import { ApiCallType, ApiClientConfig, ProcessRequestData, ProcessSearchRequest } from "./types";
+export declare const apiClient: ApiClient;
+declare const UnmeshedClient: {
+    initialize: (config: ApiClientConfig) => void;
+    runProcessSync: (ProcessRequestData: ProcessRequestData) => Promise<import("./types").ProcessData>;
+    runProcessAsync: (ProcessRequestData: ProcessRequestData) => Promise<import("./types").ProcessData>;
+    getProcessData: (processId: number) => Promise<import("./types").ProcessData>;
+    getStepData: (stepId: number | null) => Promise<import("./types").StepData>;
+    bulkTerminate: (processIds: number[], reason?: string) => Promise<import("./types").ProcessActionResponseData>;
+    bulkResume: (processIds: number[]) => Promise<import("./types").ProcessActionResponseData>;
+    bulkReviewed: (processIds: number[], reason?: string) => Promise<import("./types").ProcessActionResponseData>;
+    rerun: (processId: number, clientId: string, version?: number) => Promise<import("./types").ProcessData>;
+    searchProcessExecutions: (params: ProcessSearchRequest) => Promise<any>;
+    invokeApiMappingGet: (endpoint: string, id: string, correlationId: string, apiCallType: ApiCallType) => Promise<any>;
+    invokeApiMappingPost: (endpoint: string, input: Record<string, any>, id: string, correlationId: string, apiCallType?: ApiCallType) => Promise<any>;
+    renewRegistration: () => Promise<string>;
+    pollForWorkers: typeof pollForWorkers;
+};
+export default UnmeshedClient;

package/dist/index.js

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestAPI = exports.configure = void 0;
-const config_1 = require("./config");
-const TestApi = require("./testApi");
-const configure = (apiConfig) => {
-    config_1.default.setConfig(apiConfig);
+exports.apiClient = void 0;
+const apiClient_1 = require("./apiClient");
+const pollerClientImpl_1 = require("./poller/pollerClientImpl");
+const processClientImpl_1 = require("./process/processClientImpl");
+const registrationClientImpl_1 = require("./registration/registrationClientImpl");
+exports.apiClient = new apiClient_1.ApiClient();
+const UnmeshedClient = {
+    initialize: (config) => exports.apiClient.initialize(config),
+    runProcessSync: processClientImpl_1.runProcessSync,
+    runProcessAsync: processClientImpl_1.runProcessAsync,
+    getProcessData: processClientImpl_1.getProcessData,
+    getStepData: processClientImpl_1.getStepData,
+    bulkTerminate: processClientImpl_1.bulkTerminate,
+    bulkResume: processClientImpl_1.bulkResume,
+    bulkReviewed: processClientImpl_1.bulkReviewed,
+    rerun: processClientImpl_1.rerun,
+    searchProcessExecutions: processClientImpl_1.searchProcessExecutions,
+    invokeApiMappingGet: processClientImpl_1.invokeApiMappingGet,
+    invokeApiMappingPost: processClientImpl_1.invokeApiMappingPost,
+    renewRegistration: registrationClientImpl_1.renewRegistration,
+    pollForWorkers: pollerClientImpl_1.default,
 };
-exports.configure = configure;
-exports.TestAPI = TestApi;
+exports.default = UnmeshedClient;

package/dist/poller/pollerClientImpl.d.ts

@@ -0,0 +1,2 @@
+import { UnmeshedWorkerConfig } from "../types";
+export default function pollForWorkers(workers: UnmeshedWorkerConfig[]): Promise<void>;

package/dist/poller/pollerClientImpl.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = pollForWorkers;
+const __1 = require("..");
+const types_1 = require("../types");
+async function registerPolling(data) {
+    const attempt = async () => {
+        try {
+            const response = await __1.apiClient.put("/api/clients/register", {
+                data: data,
+            });
+            console.log("Successfully executed polling registration...");
+            return response.data;
+        }
+        catch {
+            console.error("An error occurred during polling registration. Retrying in 3 seconds...");
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            return attempt();
+        }
+    };
+    return attempt();
+}
+async function pollWorker(data) {
+    try {
+        const response = await __1.apiClient.post("/api/clients/poll", {
+            data: data,
+        });
+        console.log("Succesfully executed worker polling...");
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error occurred during worker polling", error);
+    }
+}
+async function pollWorkerResult(data) {
+    try {
+        const response = await __1.apiClient.post("/api/clients/bulkResults", {
+            data: data,
+        });
+        console.log("Worker Result returned successfully...");
+        return response.data;
+    }
+    catch (error) {
+        console.log("Error:", error);
+    }
+}
+async function pollForWorkers(workers) {
+    const registerPollingData = workers.map((worker) => {
+        return {
+            orgId: 0,
+            namespace: worker.namespace,
+            stepType: "WORKER",
+            name: worker.name,
+        };
+    });
+    await registerPolling(registerPollingData);
+    const pollWorkerData = workers.map((worker) => {
+        return {
+            stepQueueNameData: {
+                orgId: 0,
+                namespace: worker.namespace,
+                stepType: "WORKER",
+                name: worker.name,
+            },
+            size: worker.maxInProgress,
+        };
+    });
+    const pollResponse = await pollWorker(pollWorkerData);
+    const workerResult = await Promise.all(pollResponse.map(async (polledWorker) => {
+        const associatedWorker = workers.find((worker) => worker.name === polledWorker.stepName &&
+            worker.namespace === polledWorker.stepNamespace);
+        let workerResponse = {
+            processId: polledWorker.processId,
+            stepId: polledWorker.stepId,
+            stepExecutionId: polledWorker.stepExecutionId,
+            runCount: polledWorker.runCount,
+            output: {},
+            status: types_1.StepStatus.RUNNING,
+            rescheduleAfterSeconds: null,
+            startedAt: new Date().getTime(),
+        };
+        const TIMEOUT = 1000;
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("Timed out")), TIMEOUT);
+        });
+        try {
+            const result = await Promise.race([
+                associatedWorker.worker(polledWorker.inputParam),
+                timeoutPromise,
+            ]);
+            workerResponse = {
+                ...workerResponse,
+                output: {
+                    ...result,
+                    __workCompletedAt: new Date().getTime(),
+                },
+                status: types_1.StepStatus.COMPLETED,
+            };
+        }
+        catch (error) {
+            if (error.message === "Timed out") {
+                workerResponse = {
+                    ...workerResponse,
+                    output: {
+                        error: error.message,
+                    },
+                    status: types_1.StepStatus.TIMED_OUT,
+                };
+            }
+            else {
+                workerResponse = {
+                    ...workerResponse,
+                    output: {
+                        error: error.message,
+                    },
+                    status: types_1.StepStatus.FAILED,
+                };
+                console.error("Error:", error.message);
+            }
+        }
+        return workerResponse;
+    }));
+    const workerResultResponse = await pollWorkerResult(workerResult);
+    console.log("Worker result : ", workerResultResponse);
+}

package/dist/process/processClientImpl.d.ts

@@ -0,0 +1,12 @@
+import { ApiCallType, ProcessSearchRequest, ProcessActionResponseData, ProcessData, ProcessRequestData, StepData } from "../types";
+export declare const runProcessSync: (ProcessRequestData: ProcessRequestData) => Promise<ProcessData>;
+export declare const runProcessAsync: (ProcessRequestData: ProcessRequestData) => Promise<ProcessData>;
+export declare const getProcessData: (processId: number) => Promise<ProcessData>;
+export declare const getStepData: (stepId: number | null) => Promise<StepData>;
+export declare const bulkTerminate: (processIds: number[], reason?: string) => Promise<ProcessActionResponseData>;
+export declare const bulkResume: (processIds: number[]) => Promise<ProcessActionResponseData>;
+export declare const bulkReviewed: (processIds: number[], reason?: string) => Promise<ProcessActionResponseData>;
+export declare const rerun: (processId: number, clientId: string, version?: number) => Promise<ProcessData>;
+export declare const searchProcessExecutions: (params: ProcessSearchRequest) => Promise<any>;
+export declare const invokeApiMappingGet: (endpoint: string, id: string, correlationId: string, apiCallType: ApiCallType) => Promise<any>;
+export declare const invokeApiMappingPost: (endpoint: string, input: Record<string, any>, id: string, correlationId: string, apiCallType?: ApiCallType) => Promise<any>;

package/dist/process/processClientImpl.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeApiMappingPost = exports.invokeApiMappingGet = exports.searchProcessExecutions = exports.rerun = exports.bulkReviewed = exports.bulkResume = exports.bulkTerminate = exports.getStepData = exports.getProcessData = exports.runProcessAsync = exports.runProcessSync = void 0;
+const __1 = require("..");
+const types_1 = require("../types");
+const RUN_PROCESS_REQUEST_URL = "api/process/";
+const runProcessSync = async (ProcessRequestData) => {
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "runSync", {
+            data: ProcessRequestData,
+            params: {
+                clientId: __1.apiClient.getClientId(),
+            },
+        });
+        console.log("Response:", response);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Some error occurred running process request : ", error);
+        throw error;
+    }
+};
+exports.runProcessSync = runProcessSync;
+const runProcessAsync = async (ProcessRequestData) => {
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "runAsync", {
+            data: ProcessRequestData,
+            params: {
+                clientId: __1.apiClient.getClientId(),
+            },
+        });
+        console.log("Response:", response);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Some error occurred running process request : ", error);
+        throw error;
+    }
+};
+exports.runProcessAsync = runProcessAsync;
+const getProcessData = async (processId) => {
+    if (processId == null) {
+        throw new Error("Process ID cannot be null");
+    }
+    try {
+        const response = await __1.apiClient.get(RUN_PROCESS_REQUEST_URL + "context/" + processId);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error occurred while fetching process record: ", error);
+        throw error;
+    }
+};
+exports.getProcessData = getProcessData;
+const getStepData = async (stepId) => {
+    if (stepId === null || stepId === undefined) {
+        throw new Error("Step ID cannot be null or undefined");
+    }
+    try {
+        const response = await __1.apiClient.get(RUN_PROCESS_REQUEST_URL + "stepContext/" + stepId);
+        return response.data;
+    }
+    catch (error) {
+        throw new Error(`Error occurred while fetching step record: ${error.message || error}`);
+    }
+};
+exports.getStepData = getStepData;
+const bulkTerminate = async (processIds, reason) => {
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "bulkTerminate", {
+            params: { reason },
+            data: processIds,
+        });
+        return response.data;
+    }
+    catch (error) {
+        throw new Error(`Error occurred while terminating processes: ${error.message || error}`);
+    }
+};
+exports.bulkTerminate = bulkTerminate;
+const bulkResume = async (processIds) => {
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "bulkResume", {
+            data: processIds,
+        });
+        return response.data;
+    }
+    catch (error) {
+        throw new Error(`Error occurred while resuming processes: ${error.message || error}`);
+    }
+};
+exports.bulkResume = bulkResume;
+const bulkReviewed = async (processIds, reason) => {
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "bulkReviewed", {
+            data: processIds,
+            params: { reason },
+        });
+        return response.data;
+    }
+    catch (error) {
+        throw new Error(`Error occurred while marking processes as reviewed: ${error.message || error}`);
+    }
+};
+exports.bulkReviewed = bulkReviewed;
+const rerun = async (processId, clientId, version) => {
+    var _a, _b;
+    const params = {
+        clientId,
+        processId,
+    };
+    if (version !== undefined) {
+        params["version"] = version;
+    }
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "rerun", {
+            params,
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (error.isAxiosError) {
+            throw new Error(`HTTP request error during rerun process: ${(_a = error.response) === null || _a === void 0 ? void 0 : _a.status} - ${(_b = error.response) === null || _b === void 0 ? void 0 : _b.data}`);
+        }
+        else {
+            throw new Error(`Unexpected error during rerun process: ${error.message}`);
+        }
+    }
+};
+exports.rerun = rerun;
+const searchProcessExecutions = async (params) => {
+    const queryParams = new URLSearchParams();
+    if (params.startTimeEpoch !== undefined && params.startTimeEpoch !== 0)
+        queryParams.set("startTimeEpoch", params.startTimeEpoch.toString());
+    if (params.endTimeEpoch !== undefined && params.endTimeEpoch !== 0)
+        queryParams.set("endTimeEpoch", params.endTimeEpoch.toString());
+    if (params.namespace)
+        queryParams.set("namespace", params.namespace);
+    if (params.names && params.names.length)
+        queryParams.set("names", params.names.join(","));
+    if (params.processIds && params.processIds.length)
+        queryParams.set("processIds", params.processIds.join(","));
+    if (params.correlationIds && params.correlationIds.length)
+        queryParams.set("correlationIds", params.correlationIds.join(","));
+    if (params.requestIds && params.requestIds.length)
+        queryParams.set("requestIds", params.requestIds.join(","));
+    if (params.statuses && params.statuses.length)
+        queryParams.set("statuses", params.statuses.join(","));
+    if (params.triggerTypes && params.triggerTypes.length)
+        queryParams.set("triggerTypes", params.triggerTypes.join(","));
+    const updatedParams = Object.fromEntries(new URLSearchParams(queryParams));
+    try {
+        const response = await __1.apiClient.get(RUN_PROCESS_REQUEST_URL + "api/stats/process/search", updatedParams);
+        console.log("Response:", response);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error occurred while searching process executions: ", error);
+        throw error;
+    }
+};
+exports.searchProcessExecutions = searchProcessExecutions;
+const invokeApiMappingGet = async (endpoint, id, correlationId, apiCallType) => {
+    try {
+        const response = await __1.apiClient.get(RUN_PROCESS_REQUEST_URL + "api/call/" + endpoint, {
+            id: id,
+            correlationId: correlationId,
+            apiCallType,
+        });
+        console.log("Response:", response);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error occurred while invoking API Mapping GET: ", error);
+        throw error;
+    }
+};
+exports.invokeApiMappingGet = invokeApiMappingGet;
+const invokeApiMappingPost = async (endpoint, input, id, correlationId, apiCallType = types_1.ApiCallType.ASYNC) => {
+    try {
+        const response = await __1.apiClient.post(RUN_PROCESS_REQUEST_URL + "api/call/" + endpoint, {
+            data: input,
+            params: {
+                id: id,
+                correlationId: correlationId,
+                apiCallType,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error occurred while invoking API Mapping POST: ", error);
+        throw error;
+    }
+};
+exports.invokeApiMappingPost = invokeApiMappingPost;

package/dist/registration/registrationClientImpl.d.ts

@@ -0,0 +1 @@
+export declare const renewRegistration: () => Promise<string>;

package/dist/registration/registrationClientImpl.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renewRegistration = void 0;
+const __1 = require("..");
+const renewRegistration = async () => {
+    try {
+        const response = await __1.apiClient.put("/api/clients/register", {
+            params: {
+                friendlyName: "Unmeshed",
+                tokenExpiryDate: "",
+            },
+        });
+        console.debug("Response from server:", response);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error occurred during registration renewal:", error);
+        throw error;
+    }
+};
+exports.renewRegistration = renewRegistration;

package/dist/sample/sampleAPI.d.ts

@@ -0,0 +1,2 @@
+export declare const getApi: () => Promise<void>;
+export declare const postApi: () => Promise<import("../types").ApiResponse<any>>;

package/dist/sample/sampleAPI.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postApi = exports.getApi = void 0;
+const __1 = require("..");
+const getApi = async () => {
+    try {
+        const response = await __1.apiClient.get("/api/schedules", {
+            name: "test_name",
+        });
+        console.log("Response:", response);
+    }
+    catch (error) {
+        console.error("Error occurred:", error);
+    }
+};
+exports.getApi = getApi;
+const postApi = async () => {
+    try {
+        const response = await __1.apiClient.post("/api/test/post", {
+            data: { name: "test_name" },
+        });
+        console.log("Response:", response);
+        return response;
+    }
+    catch (error) {
+        console.error("Error occurred:", error);
+    }
+};
+exports.postApi = postApi;

package/dist/sample/sampleServer.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/dist/sample/sampleServer.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+const types_1 = require("../types");
+require("dotenv/config");
+const ArithmeticWorker_1 = require("./workers/ArithmeticWorker");
+const BASE_URL = process.env.UNMESHED_BASE_URL;
+const PORT = process.env.UNMESHED_PORT;
+const ClIENT_ID = process.env.UNMESHED_CLIENT_ID;
+const AUTH_TOKEN = process.env.UNMESHED_AUTH_TOKEN;
+__1.default.initialize({
+    baseUrl: BASE_URL,
+    port: PORT,
+    clientId: ClIENT_ID,
+    authToken: AUTH_TOKEN,
+});
+const request = {
+    name: "sample-http",
+    namespace: "default",
+    input: {},
+    correlationId: "",
+    requestId: "",
+    version: 1,
+};
+const workers = [
+    {
+        worker: (input) => (0, ArithmeticWorker_1.ArithmeticOperation)(input),
+        namespace: "default",
+        name: "arithmetic_operation_worker",
+        maxInProgress: 10,
+    },
+];
+// UnmeshedClient.pollForWorkers(workers);
+const processId = 28878569;
+const stepId = 28878571;
+const processIds = [34, 344];
+const clientId = "jdjfjf";
+const endpoint = "your-endpoint";
+const input = { key: "value" };
+const id = "12345";
+const apiCallType = types_1.ApiCallType.SYNC;
+const params = {
+    startTimeEpoch: 1673606400000,
+    endTimeEpoch: 1673692800000,
+    namespace: "default",
+    processTypes: [types_1.ProcessType.STANDARD],
+    triggerTypes: [types_1.ProcessTriggerType.MANUAL],
+    names: ["process1", "process2", "process3"],
+    processIds: [28883174, 28883162],
+    correlationIds: ["correlationId1", "correlationId2"],
+    requestIds: ["requestId1", "requestId2"],
+    statuses: [types_1.ProcessStatus.COMPLETED],
+    limit: 10,
+    offset: 0,
+};
+// UnmeshedClient.getStepData(stepId)
+//   .then((stepData) => {
+//     console.log("STEP_DATA", stepData);
+//   })
+//   .catch((error) => {
+//     console.error("Error fetching step data:", error.message);
+//   });
+// UnmeshedClient.rerun(processId, ClIENT_ID)
+//   .then((data) => {
+//     console.log("PROCESS_DATA", data);
+//   })
+//   .catch((error) => {
+//     console.error("Error fetching step data:", error.message);
+//   });
+__1.default.bulkTerminate(processIds)
+    .then((data) => {
+    console.log("PROCESS_DATA", data);
+})
+    .catch((error) => {
+    console.error("Error fetching step data:", error.message);
+});

package/dist/sample/workers/ArithmeticWorker.d.ts

@@ -0,0 +1,5 @@
+type ArithmeticOutput = {
+    result: number | string;
+};
+export declare const ArithmeticOperation: (input: Record<string, any>) => Promise<ArithmeticOutput>;
+export {};