@unmeshed/sdk 1.0.9 → 1.0.11

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/unmeshed-javascript-sdk.iml" filepath="$PROJECT_DIR$/.idea/unmeshed-javascript-sdk.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/unmeshed-javascript-sdk.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/p.json

@@ -0,0 +1,25 @@
+{
+  "name": "@unmeshed/sdk",
+  "version": "1.0.10",
+  "description": "Unmeshed SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "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",
+    "dotenv": "^16.4.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.6"
+  }
+}

package/package.json

@@ -1,24 +1,23 @@
 {
   "name": "@unmeshed/sdk",
-  "version": "1.0.9",
-  "description": "Unmeshed SDK",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "1.0.11",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc --build --verbose",
     "dev": "tsc && node dist/sample/sampleServer.js",
     "start": "tsc && node dist/sample/sampleServer.js",
-    "publishToNpm": "tsc && npm publish --access public"
+    "publishToNpm": "tsc && npm publish --access public",
+    "clean": "rm -rf dist && rm -f tsconfig.tsbuildinfo"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/node": "^22.10.6",
+    "@tsconfig/node18": "^18.2.4"
   },
-  "files": [
-    "/dist"
-  ],
   "dependencies": {
     "@types/axios": "^0.14.4",
     "axios": "^1.7.9",
     "dotenv": "^16.4.7"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.6"
   }
 }

package/src/apiClient.ts

@@ -0,0 +1,142 @@
+import axios, { AxiosError, AxiosInstance, AxiosResponse } from "axios";
+import {
+  ApiClientConfig,
+  ApiResponse,
+  ClientRequestConfig,
+  HandleRequestConfig,
+  QueryParams,
+  RequestConfig,
+} from "./types";
+import { UnmeshedCommonUtils } from "./utils/unmeshedCommonUtils";
+
+export class ApiClient {
+  private axiosInstance: AxiosInstance | null = null;
+  private clientId: string | undefined = undefined;
+
+  public initialize(config: ApiClientConfig): void {
+    console.log("Initializing Unmeshed ApiClient");
+    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.create({
+      baseURL,
+      timeout,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer client.sdk.${clientId}.${UnmeshedCommonUtils.createSecureHash(
+          authToken
+        )}`,
+      },
+    });
+  }
+
+  private validateInstance(): void {
+    if (!this.axiosInstance) {
+      throw new Error("ApiClient must be initialized before making requests");
+    }
+  }
+
+  private async handleRequest<T>({
+                                   method,
+                                   endpoint,
+                                   params,
+                                   data,
+                                   config,
+                                 }: HandleRequestConfig): Promise<ApiResponse<T>> {
+    this.validateInstance();
+
+    try {
+      // Assert that axiosInstance exists before using it
+      if (!this.axiosInstance) {
+        throw new Error("Axios instance is not initialized");
+      }
+
+      const response: AxiosResponse<T> = await this.axiosInstance.request<T>({
+        method,
+        url: endpoint,
+        params,
+        data,
+        ...config,
+      });
+
+      return {
+        data: response.data,
+        status: response.status,
+        headers: response.headers as Record<string, string>,
+      };
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        console.error("Request failed:", error.message);
+        throw this.handleError(error);
+      } else {
+        console.error("Unexpected error:", (error as Error).message);
+        throw error;
+      }
+    }
+  }
+
+  private handleError(error: AxiosError) {
+    console.error("Error details:", {
+      message: error.message,
+      status: error.response?.status,
+      data: error.response?.data,
+    });
+  }
+
+  public async get<T = any>(
+    endpoint: string,
+    params?: QueryParams,
+    config?: RequestConfig
+  ): Promise<ApiResponse<T>> {
+    return this.handleRequest<T>({
+      method: "get",
+      endpoint: endpoint,
+      params: params,
+      config: config,
+    });
+  }
+
+  public async post<T = any>(
+    endpoint: string,
+    clientRequestConfig: ClientRequestConfig
+  ): Promise<ApiResponse<T>> {
+    return this.handleRequest<T>({
+      method: "post",
+      endpoint: endpoint,
+      ...clientRequestConfig,
+    });
+  }
+
+  public async put<T = any>(
+    endpoint: string,
+    clientRequestConfig: ClientRequestConfig
+  ): Promise<ApiResponse<T>> {
+    return this.handleRequest<T>({
+      method: "put",
+      endpoint: endpoint,
+      ...clientRequestConfig,
+    });
+  }
+
+  public async delete<T = any>(
+    endpoint: string,
+    clientRequestConfig: ClientRequestConfig
+  ): Promise<ApiResponse<T>> {
+    return this.handleRequest<T>({
+      method: "delete",
+      endpoint: endpoint,
+      ...clientRequestConfig,
+    });
+  }
+
+  public getClientId(): string | undefined {
+    return this.clientId;
+  }
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+import { ApiClient } from "./apiClient";
+import pollForWorkers from "./poller/pollerClientImpl";
+import {
+  bulkResume,
+  bulkReviewed,
+  bulkTerminate,
+  getProcessData,
+  getStepData,
+  invokeApiMappingGet,
+  invokeApiMappingPost,
+  rerun,
+  runProcessAsync,
+  runProcessSync,
+  searchProcessExecutions,
+} from "./process/processClientImpl";
+import { renewRegistration } from "./registration/registrationClientImpl";
+import {
+  ApiCallType,
+  ApiClientConfig,
+  ProcessRequestData,
+  ProcessSearchRequest,
+} from "./types";
+
+export const apiClient = new ApiClient();
+
+const UnmeshedClient = {
+  initialize: (config: ApiClientConfig) => apiClient.initialize(config),
+  runProcessSync,
+  runProcessAsync,
+  getProcessData,
+  getStepData,
+  bulkTerminate,
+  bulkResume,
+  bulkReviewed,
+  rerun,
+  searchProcessExecutions,
+  invokeApiMappingGet,
+  invokeApiMappingPost,
+  renewRegistration,
+  pollForWorkers,
+};
+
+export default UnmeshedClient;

package/src/poller/pollerClientImpl.ts

@@ -0,0 +1,150 @@
+import { apiClient } from "..";
+import {
+  PollRequestData,
+  StepQueueNameData,
+  StepStatus,
+  UnmeshedWorkerConfig,
+  WorkRequest,
+  WorkResponse,
+} from "../types";
+
+async function registerPolling(data: StepQueueNameData[]) {
+  const attempt = async (): Promise<any> => {
+    try {
+      const response = await 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: PollRequestData[]) {
+  try {
+    const response = await 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: WorkResponse[]) {
+  try {
+    const response = await apiClient.post("/api/clients/bulkResults", {
+      data: data,
+    });
+    console.log("Worker Result returned successfully...");
+    return response.data;
+  } catch (error) {
+    console.log("Error:", error);
+  }
+}
+
+export default async function pollForWorkers(workers: UnmeshedWorkerConfig[]) {
+  const registerPollingData = workers.map((worker) => {
+    return {
+      orgId: 0,
+      namespace: worker.namespace,
+      stepType: "WORKER",
+      name: worker.name,
+    } as StepQueueNameData;
+  });
+  await registerPolling(registerPollingData);
+  const pollWorkerData = workers.map((worker) => {
+    return {
+      stepQueueNameData: {
+        orgId: 0,
+        namespace: worker.namespace,
+        stepType: "WORKER",
+        name: worker.name,
+      },
+      size: worker.maxInProgress,
+    } as PollRequestData;
+  });
+
+  const pollResponse = await pollWorker(pollWorkerData);
+
+  const workerResult: WorkResponse[] = await Promise.all(
+    pollResponse.map(async (polledWorker: WorkRequest) => {
+      const associatedWorker: UnmeshedWorkerConfig | undefined = workers.find(
+        (worker) =>
+          worker.name === polledWorker.stepName &&
+          worker.namespace === polledWorker.stepNamespace
+      );
+
+      if(!associatedWorker) {
+        throw Error(`No worker found for ${polledWorker.stepName} ${polledWorker.stepNamespace}`)
+      }
+
+      let workerResponse: WorkResponse = {
+        processId: polledWorker.processId,
+        stepId: polledWorker.stepId,
+        stepExecutionId: polledWorker.stepExecutionId,
+        runCount: polledWorker.runCount,
+        output: {},
+        status: 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: StepStatus.COMPLETED,
+        };
+      } catch (error: unknown) {
+        const err = error as Error;
+        if (err.message === "Timed out") {
+          workerResponse = {
+            ...workerResponse,
+            output: {
+              error: err.message,
+            },
+            status: StepStatus.TIMED_OUT,
+          };
+        } else {
+          workerResponse = {
+            ...workerResponse,
+            output: {
+              error: err.message,
+            },
+            status: StepStatus.FAILED,
+          };
+          console.error("Error:", err.message);
+        }
+      }
+
+      return workerResponse;
+    })
+  );
+
+  const workerResultResponse = await pollWorkerResult(workerResult);
+  console.log("Worker result : ", workerResultResponse);
+}

package/src/process/processClientImpl.ts

@@ -0,0 +1,267 @@
+import {apiClient} from "..";
+import {
+  ApiCallType,
+  ProcessActionResponseData,
+  ProcessData,
+  ProcessRequestData,
+  ProcessSearchRequest,
+  StepData,
+} from "../types";
+import {isAxiosError} from "axios";
+
+const RUN_PROCESS_REQUEST_URL = "api/process/";
+
+export const runProcessSync = async (
+  ProcessRequestData: ProcessRequestData
+): Promise<ProcessData> => {
+  try {
+    const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "runSync", {
+      data: ProcessRequestData,
+      params: {
+        clientId: apiClient.getClientId(),
+      },
+    });
+    console.log("Response:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Some error occurred running process request : ", error);
+    throw error;
+  }
+};
+
+export const runProcessAsync = async (
+  ProcessRequestData: ProcessRequestData
+): Promise<ProcessData> => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "runAsync",
+      {
+        data: ProcessRequestData,
+        params: {
+          clientId: apiClient.getClientId(),
+        },
+      }
+    );
+    console.log("Response:", response);
+    return response.data;
+  } catch (error) {
+    console.error("Some error occurred running process request : ", error);
+    throw error;
+  }
+};
+
+export const getProcessData = async (
+  processId: number
+): Promise<ProcessData> => {
+  if (processId == null) {
+    throw new Error("Process ID cannot be null");
+  }
+  try {
+    const response = await apiClient.get<ProcessData>(
+      RUN_PROCESS_REQUEST_URL + "context/" + processId
+    );
+    return response.data;
+  } catch (error) {
+    console.error("Error occurred while fetching process record: ", error);
+    throw error;
+  }
+};
+
+export const getStepData = async (stepId: number | null): Promise<StepData> => {
+  if (stepId === null || stepId === undefined) {
+    throw new Error("Step ID cannot be null or undefined");
+  }
+
+  try {
+    const response = await apiClient.get<StepData>(
+      RUN_PROCESS_REQUEST_URL + "stepContext/" + stepId
+    );
+    return response.data;
+  } catch (error) {
+    const err = error as Error;
+    throw new Error(
+      `Error occurred while fetching step record: ${err.message || error}`
+    );
+  }
+};
+
+export const bulkTerminate = async (
+  processIds: number[],
+  reason?: string
+): Promise<ProcessActionResponseData> => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "bulkTerminate",
+      {
+        params: { reason },
+        data: processIds,
+      }
+    );
+    return response.data as ProcessActionResponseData;
+  } catch (error) {
+    const err = error as Error;
+    throw new Error(
+      `Error occurred while terminating processes: ${err.message || error}`
+    );
+  }
+};
+
+export const bulkResume = async (
+  processIds: number[]
+): Promise<ProcessActionResponseData> => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "bulkResume",
+      {
+        data: processIds,
+      }
+    );
+    return response.data as ProcessActionResponseData;
+  } catch (error) {
+    const err = error as Error;
+    throw new Error(
+      `Error occurred while resuming processes: ${err.message || error}`
+    );
+  }
+};
+
+export const bulkReviewed = async (
+  processIds: number[],
+  reason?: string
+): Promise<ProcessActionResponseData> => {
+  try {
+    const response = await apiClient.post(
+      RUN_PROCESS_REQUEST_URL + "bulkReviewed",
+      {
+        data: processIds,
+        params: { reason },
+      }
+    );
+    return response.data as ProcessActionResponseData;
+  } catch (error) {
+    const err = error as Error;
+    throw new Error(
+      `Error occurred while marking processes as reviewed: ${err.message || error}`
+    );
+  }
+};
+
+export const rerun = async (
+  processId: number,
+  clientId: string,
+  version?: number
+): Promise<ProcessData> => {
+  const params: Record<string, any> = {
+    clientId,
+    processId,
+  };
+
+  if (version !== undefined) {
+    params["version"] = version;
+  }
+
+  try {
+    const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "rerun", {
+      params,
+    });
+
+    return response.data as ProcessData;
+  } catch (error) {
+    if (isAxiosError(error)) {
+      throw new Error(
+        `HTTP request error during rerun process: ${error.response?.status} - ${error.response?.data}`
+      );
+    } else {
+      const err = error as Error;
+      throw new Error(
+        `Unexpected error during rerun process: ${err.message || err}`
+      );
+    }
+  }
+};
+
+export const searchProcessExecutions = async (params: ProcessSearchRequest) => {
+  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 || 0).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 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;
+  }
+};
+
+export const invokeApiMappingGet = async (
+  endpoint: string,
+  id: string,
+  correlationId: string,
+  apiCallType: ApiCallType
+) => {
+  try {
+    const response = await 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;
+  }
+};
+
+export const invokeApiMappingPost = async (
+  endpoint: string,
+  input: Record<string, any>,
+  id: string,
+  correlationId: string,
+  apiCallType: ApiCallType = ApiCallType.ASYNC
+): Promise<any> => {
+  try {
+    const response = await 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;
+  }
+};