@unmeshed/sdk 1.0.5 → 1.0.7

package/dist/apiClient.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = require("axios");
+const unmeshedCommonUtils_1 = require("./utils/unmeshedCommonUtils");
+class ApiClient {
+    constructor() {
+        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: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer client.sdk.${clientId}.${unmeshedCommonUtils_1.UnmeshedCommonUtils.createSecureHash(authToken)}`,
+            },
+        });
+    }
+    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,
+        });
+    }
+    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,
+        });
+    }
+    getClientId() {
+        return this.clientId;
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/index.d.ts

@@ -1 +1,21 @@
-export { sayHello, sayGoodbye } from './hello-world';
+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,6 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sayGoodbye = exports.sayHello = void 0;
-var hello_world_1 = require("./hello-world");
-Object.defineProperty(exports, "sayHello", { enumerable: true, get: function () { return hello_world_1.sayHello; } });
-Object.defineProperty(exports, "sayGoodbye", { enumerable: true, get: function () { return hello_world_1.sayGoodbye; } });
+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.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 {};

package/dist/sample/workers/ArithmeticWorker.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArithmeticOperation = void 0;
+const ArithmeticOperation = async (input) => {
+    const { operation, num1, num2 } = input;
+    console.info(`Performing ${operation} operation on ${num1} and ${num2}`);
+    switch (operation.toLowerCase()) {
+        case "add":
+            return { result: num1 + num2 };
+        case "subtract":
+            return { result: num1 - num2 };
+        case "multiply":
+            return { result: num1 * num2 };
+        case "divide":
+            if (num2 === 0) {
+                throw new Error("Division by zero is not allowed");
+            }
+            return { result: num1 / num2 };
+        default:
+            throw new Error("Invalid operation");
+    }
+};
+exports.ArithmeticOperation = ArithmeticOperation;

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

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

package/dist/sample/workers/DelayedWorker.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelayedWorkers = void 0;
+const DelayedWorkers = async () => {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve("Function executed after 10 seconds");
+        }, 10000);
+    });
+};
+exports.DelayedWorkers = DelayedWorkers;

package/dist/server.d.ts

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

package/dist/server.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const types_1 = require("./types");
+require("dotenv/config");
+_1.default.initialize({
+    baseUrl: process.env.UNMESHED_BASE_URL,
+    port: process.env.UNMESHED_PORT,
+    clientId: process.env.UNMESHED_CLIENT_ID,
+    authToken: process.env.UNMESHED_AUTH_TOKEN,
+});
+const request = {
+    name: "sample-http",
+    namespace: "default",
+    input: {},
+    correlationId: "",
+    requestId: "",
+    version: 1,
+};
+const workers = [
+//   {
+//     worker: async (input) => {
+//       return new Promise((resolve, reject) => {
+//         if (!input) {
+//           reject(new Error("Input is required"));
+//         } else {
+//           console.log("Input:", input);
+//           resolve(input);
+//         }
+//       });
+//     },
+//     namespace: "default",
+//     name: "test_sdk_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: [12345, 67890],
+    correlationIds: ["correlationId1", "correlationId2"],
+    requestIds: ["requestId1", "requestId2"],
+    statuses: [types_1.ProcessStatus.COMPLETED],
+    limit: 10,
+    offset: 0,
+};
+const stepData = _1.default.getStepData(stepId);
+//  UnmeshedClient.rerun(processId,process.env.UNMESHED_CLIENT_ID)
+console.log("server res", stepData);

package/dist/types/index.d.ts

@@ -0,0 +1,313 @@
+import { AxiosRequestConfig } from "axios";
+export declare enum ApiCallType {
+    SYNC = "SYNC",
+    ASYNC = "ASYNC",
+    STREAM = "STREAM"
+}
+export interface ApiMappingData {
+    endpoint: string;
+    processDefNamespace: string;
+    processDefName: string;
+    processDefVersion: number;
+    authType: string;
+    authClaims: string;
+    createdBy: string;
+    updatedBy: string;
+    created: Date;
+    updated: Date;
+}
+export type ApiMappingWebhookData = {
+    endpoint: string;
+    name: string;
+    uniqueId: string;
+    urlSecret: string;
+    description: string;
+    userIdentifier: string;
+    webhookSource: WebhookSource;
+    webhookSourceConfig: Record<string, string>;
+    expiryDate: Date;
+    userType: SQAuthUserType;
+    createdBy: string;
+    updatedBy: string;
+    created: Date;
+    updated: Date;
+};
+export declare enum WebhookSource {
+    MS_TEAMS = "MS_TEAMS",
+    NOT_DEFINED = "NOT_DEFINED"
+}
+export declare enum SQAuthUserType {
+    USER = "USER",
+    API = "API",
+    INTERNAL = "INTERNAL"
+}
+export declare enum StepType {
+    WORKER = "WORKER",
+    HTTP = "HTTP",
+    WAIT = "WAIT",
+    FAIL = "FAIL",
+    PYTHON = "PYTHON",
+    JAVASCRIPT = "JAVASCRIPT",
+    JQ = "JQ",
+    MANAGED = "MANAGED",
+    BUILTIN = "BUILTIN",
+    NOOP = "NOOP",
+    PERSISTED_STATE = "PERSISTED_STATE",
+    DEPENDSON = "DEPENDSON",
+    INTEGRATION = "INTEGRATION",
+    EXIT = "EXIT",
+    SUB_PROCESS = "SUB_PROCESS",
+    LIST = "LIST",
+    PARALLEL = "PARALLEL",
+    FOREACH = "FOREACH",
+    SWITCH = "SWITCH"
+}
+export declare enum StepStatus {
+    PENDING = "PENDING",
+    SCHEDULED = "SCHEDULED",
+    RUNNING = "RUNNING",
+    PAUSED = "PAUSED",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    TIMED_OUT = "TIMED_OUT",
+    SKIPPED = "SKIPPED",
+    CANCELLED = "CANCELLED"
+}
+export declare enum ProcessStatus {
+    RUNNING = "RUNNING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    TIMED_OUT = "TIMED_OUT",
+    CANCELLED = "CANCELLED",
+    TERMINATED = "TERMINATED",
+    REVIEWED = "REVIEWED"
+}
+export declare enum ProcessTriggerType {
+    MANUAL = "MANUAL",
+    SCHEDULED = "SCHEDULED",
+    API_MAPPING = "API_MAPPING",
+    WEBHOOK = "WEBHOOK",
+    API = "API",
+    SUB_PROCESS = "SUB_PROCESS"
+}
+export declare enum ProcessType {
+    STANDARD = "STANDARD",
+    DYNAMIC = "DYNAMIC",
+    API_ORCHESTRATION = "API_ORCHESTRATION",
+    INTERNAL = "INTERNAL"
+}
+export type ClientProfileData = {
+    clientId: string;
+    ipAddress: string;
+    friendlyName: string;
+    userIdentifier: string;
+    stepQueueNames: StepQueueNameData[];
+    createdBy: string;
+    updatedBy: string;
+    created: Date;
+    updated: Date;
+    expiryDate: Date;
+};
+export type FullClientProfileData = {
+    clientId: string;
+    ipAddress: string;
+    friendlyName: string;
+    userIdentifier: string;
+    stepQueueNames: StepQueueNameData[];
+    createdBy: string;
+    updatedBy: string;
+    created: Date;
+    updated: Date;
+    expiryDate: Date;
+    tokenValue: string;
+};
+export type StepQueueNameData = {
+    orgId: number;
+    namespace: string;
+    stepType: StepType;
+    name: string;
+};
+export type ProcessActionResponseData = {
+    count: number;
+    details: ProcessActionResponseDetailData[];
+};
+export type ProcessActionResponseDetailData = {
+    id: string;
+    message: string;
+    error: string;
+};
+export type ProcessData = {
+    processId: number;
+    processType: ProcessType;
+    triggerType: ProcessTriggerType;
+    namespace: string;
+    name: string;
+    version: number | null;
+    processDefinitionHistoryId: number | null;
+    requestId: string;
+    correlationId: string;
+    status: ProcessStatus;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    stepIdCount: number | null;
+    shardName: string;
+    shardInstanceId: number | null;
+    stepIds: StepId[];
+    stepDataById: Record<number, StepData>;
+    created: number;
+    updated: number;
+    createdBy: string;
+};
+export type StepData = {
+    id: number;
+    processId: number;
+    ref: string;
+    parentId: number | null;
+    parentRef: string | null;
+    namespace: string;
+    name: string;
+    type: StepType;
+    stepDefinitionHistoryId: number | null;
+    status: StepStatus;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    workerId: string;
+    start: number;
+    schedule: number;
+    priority: number;
+    updated: number;
+    optional: boolean;
+    executionList: StepExecutionData[];
+};
+export type StepExecutionData = {
+    id: number;
+    scheduled: number;
+    polled: number;
+    start: number;
+    updated: number;
+    executor: string;
+    ref: string;
+    runs: number;
+    output: Record<string, unknown>;
+};
+export type StepId = {
+    id: number;
+    processId: number;
+    ref: string;
+};
+export type ProcessRequestData = {
+    name: string;
+    namespace: string;
+    version: number | null;
+    requestId: string;
+    correlationId: string;
+    input: Record<string, unknown>;
+};
+export type ProcessSearchRequest = {
+    startTimeEpoch: number;
+    endTimeEpoch?: number | null;
+    namespace: string;
+    processTypes: ProcessType[];
+    triggerTypes: ProcessTriggerType[];
+    names: string[];
+    processIds: number[];
+    correlationIds: string[];
+    requestIds: string[];
+    statuses: ProcessStatus[];
+    limit: number;
+    offset: number;
+};
+export type StepSize = {
+    stepQueueNameData: StepQueueNameData;
+    size: number | null;
+};
+export type ClientSubmitResult = {
+    processId: number;
+    stepId: number;
+    errorMessage: string | null;
+    httpStatusCode: number | null;
+};
+export type WorkRequest = {
+    processId: number;
+    stepId: number;
+    stepExecutionId: number;
+    runCount: number;
+    stepName: string;
+    stepNamespace: string;
+    stepRef: string;
+    inputParam: Record<string, unknown>;
+    isOptional: boolean;
+    polled: number;
+    scheduled: number;
+    updated: number;
+    priority: number;
+};
+export type WorkResponse = {
+    processId: number;
+    stepId: number;
+    stepExecutionId: number;
+    runCount: number;
+    output: Record<string, unknown>;
+    status: StepStatus;
+    rescheduleAfterSeconds: number | null;
+    startedAt: number;
+};
+export type WorkResult = {
+    output: unknown;
+    taskExecutionId: string;
+    startTime: number;
+    endTime: number;
+    workRequest: WorkRequest;
+};
+export interface ApiClientConfig {
+    baseUrl: string;
+    clientId: string;
+    authToken: string;
+    port?: string | number;
+    timeout?: number;
+}
+export interface ApiResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+}
+export interface ApiError extends Error {
+    status?: number;
+    response?: {
+        data?: any;
+        status: number;
+        headers: Record<string, string>;
+    };
+}
+export interface QueryParams {
+    [key: string]: string | number | boolean | undefined;
+}
+export interface RequestConfig extends Omit<AxiosRequestConfig, "baseURL" | "url" | "method"> {
+    headers?: Record<string, string>;
+}
+export interface HandleRequestConfig {
+    method: "get" | "post" | "put" | "delete";
+    endpoint: string;
+    params?: QueryParams;
+    data?: Record<string, unknown>;
+    config?: RequestConfig;
+}
+export interface ClientRequestConfig {
+    params?: QueryParams;
+    data?: any;
+    config?: RequestConfig;
+}
+interface UnmeshedWorker {
+    (input: Record<string, any>): Promise<any>;
+}
+export interface UnmeshedWorkerConfig {
+    worker: UnmeshedWorker;
+    namespace: string;
+    name: string;
+    maxInProgress: number;
+}
+export interface PollRequestData {
+    stepQueueNameData: StepQueueNameData;
+    size: number;
+}
+export {};

package/dist/types/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessType = exports.ProcessTriggerType = exports.ProcessStatus = exports.StepStatus = exports.StepType = exports.SQAuthUserType = exports.WebhookSource = exports.ApiCallType = void 0;
+var ApiCallType;
+(function (ApiCallType) {
+    ApiCallType["SYNC"] = "SYNC";
+    ApiCallType["ASYNC"] = "ASYNC";
+    ApiCallType["STREAM"] = "STREAM";
+})(ApiCallType || (exports.ApiCallType = ApiCallType = {}));
+var WebhookSource;
+(function (WebhookSource) {
+    WebhookSource["MS_TEAMS"] = "MS_TEAMS";
+    WebhookSource["NOT_DEFINED"] = "NOT_DEFINED";
+})(WebhookSource || (exports.WebhookSource = WebhookSource = {}));
+var SQAuthUserType;
+(function (SQAuthUserType) {
+    SQAuthUserType["USER"] = "USER";
+    SQAuthUserType["API"] = "API";
+    SQAuthUserType["INTERNAL"] = "INTERNAL";
+})(SQAuthUserType || (exports.SQAuthUserType = SQAuthUserType = {}));
+var StepType;
+(function (StepType) {
+    StepType["WORKER"] = "WORKER";
+    StepType["HTTP"] = "HTTP";
+    StepType["WAIT"] = "WAIT";
+    StepType["FAIL"] = "FAIL";
+    StepType["PYTHON"] = "PYTHON";
+    StepType["JAVASCRIPT"] = "JAVASCRIPT";
+    StepType["JQ"] = "JQ";
+    StepType["MANAGED"] = "MANAGED";
+    StepType["BUILTIN"] = "BUILTIN";
+    StepType["NOOP"] = "NOOP";
+    StepType["PERSISTED_STATE"] = "PERSISTED_STATE";
+    StepType["DEPENDSON"] = "DEPENDSON";
+    StepType["INTEGRATION"] = "INTEGRATION";
+    StepType["EXIT"] = "EXIT";
+    StepType["SUB_PROCESS"] = "SUB_PROCESS";
+    StepType["LIST"] = "LIST";
+    StepType["PARALLEL"] = "PARALLEL";
+    StepType["FOREACH"] = "FOREACH";
+    StepType["SWITCH"] = "SWITCH";
+})(StepType || (exports.StepType = StepType = {}));
+var StepStatus;
+(function (StepStatus) {
+    StepStatus["PENDING"] = "PENDING";
+    StepStatus["SCHEDULED"] = "SCHEDULED";
+    StepStatus["RUNNING"] = "RUNNING";
+    StepStatus["PAUSED"] = "PAUSED";
+    StepStatus["COMPLETED"] = "COMPLETED";
+    StepStatus["FAILED"] = "FAILED";
+    StepStatus["TIMED_OUT"] = "TIMED_OUT";
+    StepStatus["SKIPPED"] = "SKIPPED";
+    StepStatus["CANCELLED"] = "CANCELLED";
+})(StepStatus || (exports.StepStatus = StepStatus = {}));
+var ProcessStatus;
+(function (ProcessStatus) {
+    ProcessStatus["RUNNING"] = "RUNNING";
+    ProcessStatus["COMPLETED"] = "COMPLETED";
+    ProcessStatus["FAILED"] = "FAILED";
+    ProcessStatus["TIMED_OUT"] = "TIMED_OUT";
+    ProcessStatus["CANCELLED"] = "CANCELLED";
+    ProcessStatus["TERMINATED"] = "TERMINATED";
+    ProcessStatus["REVIEWED"] = "REVIEWED";
+})(ProcessStatus || (exports.ProcessStatus = ProcessStatus = {}));
+var ProcessTriggerType;
+(function (ProcessTriggerType) {
+    ProcessTriggerType["MANUAL"] = "MANUAL";
+    ProcessTriggerType["SCHEDULED"] = "SCHEDULED";
+    ProcessTriggerType["API_MAPPING"] = "API_MAPPING";
+    ProcessTriggerType["WEBHOOK"] = "WEBHOOK";
+    ProcessTriggerType["API"] = "API";
+    ProcessTriggerType["SUB_PROCESS"] = "SUB_PROCESS";
+})(ProcessTriggerType || (exports.ProcessTriggerType = ProcessTriggerType = {}));
+var ProcessType;
+(function (ProcessType) {
+    ProcessType["STANDARD"] = "STANDARD";
+    ProcessType["DYNAMIC"] = "DYNAMIC";
+    ProcessType["API_ORCHESTRATION"] = "API_ORCHESTRATION";
+    ProcessType["INTERNAL"] = "INTERNAL";
+})(ProcessType || (exports.ProcessType = ProcessType = {}));

package/dist/types/unmeshedCommonUtils.d.ts

@@ -0,0 +1,3 @@
+export declare class UnmeshedCommonUtils {
+    static createSecureHash(input: string): string;
+}

package/dist/types/unmeshedCommonUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnmeshedCommonUtils = void 0;
+const crypto_1 = require("crypto");
+class UnmeshedCommonUtils {
+    static createSecureHash(input) {
+        try {
+            const hash = (0, crypto_1.createHash)("sha256");
+            hash.update(input, "utf8");
+            return hash.digest("hex");
+        }
+        catch (e) {
+            throw new Error("Error creating hash");
+        }
+    }
+}
+exports.UnmeshedCommonUtils = UnmeshedCommonUtils;

package/dist/utils/unmeshedCommonUtils.d.ts

@@ -0,0 +1,3 @@
+export declare class UnmeshedCommonUtils {
+    static createSecureHash(input: string): string;
+}

package/dist/utils/unmeshedCommonUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnmeshedCommonUtils = void 0;
+const crypto_1 = require("crypto");
+class UnmeshedCommonUtils {
+    static createSecureHash(input) {
+        try {
+            const hash = (0, crypto_1.createHash)("sha256");
+            hash.update(input, "utf8");
+            return hash.digest("hex");
+        }
+        catch (e) {
+            throw new Error("Error creating hash");
+        }
+    }
+}
+exports.UnmeshedCommonUtils = UnmeshedCommonUtils;

package/package.json

@@ -1,14 +1,23 @@
 {
   "name": "@unmeshed/sdk",
-  "version": "1.0.5",
-  "description": "Can log \"hello world\" and \"goodbye world\" to the console!",
+  "version": "1.0.7",
+  "description": "Unmeshed SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "scripts": {
+    "dev": "tsc && node dist/sample/sampleServer.js",
+    "start": "tsc && node dist/sample/sampleServer.js",
+    "publishToNpm": "tsc && npm publish --access public"
+  },
   "files": [
     "/dist"
   ],
   "dependencies": {
     "@types/axios": "^0.14.4",
-    "axios": "^1.7.9"
+    "axios": "^1.7.9",
+    "dotenv": "^16.4.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.6"
   }
 }

package/dist/hello-world.d.ts

@@ -1,2 +0,0 @@
-export declare function sayHello(): void;
-export declare function sayGoodbye(): void;

package/dist/hello-world.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sayHello = sayHello;
-exports.sayGoodbye = sayGoodbye;
-function sayHello() {
-    console.log('hi');
-}
-function sayGoodbye() {
-    console.log('goodbye');
-}