@unmeshed/sdk 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unmeshed/sdk",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "scripts": {
     "build": "tsc --build --verbose",
     "dev": "tsc && node dist/sample/sampleServer.js",

package/src/apiClient.ts

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

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

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

@@ -1,267 +0,0 @@
-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;
-  }
-};

package/src/registration/registrationClientImpl.ts

@@ -1,17 +0,0 @@
-import { apiClient } from "..";
-
-export const renewRegistration = async (): Promise<string> => {
-  try {
-    const response = await 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;
-  }
-};

package/src/sampleTest.ts

@@ -1,86 +0,0 @@
-
-import "dotenv/config";
-import UnmeshedClient from './index.js'
-
-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;
-
-console.log("UC2", UnmeshedClient)
-
-UnmeshedClient.initialize({
-  baseUrl: BASE_URL || 'abc',
-  port: PORT,
-  clientId: ClIENT_ID || 'abc',
-  authToken: AUTH_TOKEN || 'token',
-});
-
-
-
-//
-// const request = {
-//   name: "sample-http",
-//   namespace: "default",
-//   input: {},
-//   correlationId: "",
-//   requestId: "",
-//   version: 1,
-// };
-// const workers = [
-//   {
-//     worker: (input) => 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 = ApiCallType.SYNC;
-//
-// const params = {
-//   startTimeEpoch: 1673606400000,
-//   endTimeEpoch: 1673692800000,
-//   namespace: "default",
-//   processTypes: [ProcessType.STANDARD],
-//   triggerTypes: [ProcessTriggerType.MANUAL],
-//   names: ["process1", "process2", "process3"],
-//   processIds: [28883174, 28883162],
-//   correlationIds: ["correlationId1", "correlationId2"],
-//   requestIds: ["requestId1", "requestId2"],
-//   statuses: [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);
-//   });
-
-// UnmeshedClient.bulkTerminate(processIds)
-//   .then((data) => {
-//     console.log("PROCESS_DATA", data);
-//   })
-//   .catch((error) => {
-//     console.error("Error fetching step data:", error.message);
-//   });

package/src/types/index.ts

@@ -1,349 +0,0 @@
-import { AxiosRequestConfig } from "axios";
-
-export 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 enum WebhookSource {
-  MS_TEAMS = "MS_TEAMS",
-  NOT_DEFINED = "NOT_DEFINED",
-}
-
-export enum SQAuthUserType {
-  USER = "USER",
-  API = "API",
-  INTERNAL = "INTERNAL",
-}
-
-export 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 enum StepStatus {
-  PENDING = "PENDING",
-  SCHEDULED = "SCHEDULED",
-  RUNNING = "RUNNING",
-  PAUSED = "PAUSED",
-  COMPLETED = "COMPLETED",
-  FAILED = "FAILED",
-  TIMED_OUT = "TIMED_OUT",
-  SKIPPED = "SKIPPED",
-  CANCELLED = "CANCELLED",
-}
-
-export enum ProcessStatus {
-  RUNNING = "RUNNING",
-  COMPLETED = "COMPLETED",
-  FAILED = "FAILED",
-  TIMED_OUT = "TIMED_OUT",
-  CANCELLED = "CANCELLED",
-  TERMINATED = "TERMINATED",
-  REVIEWED = "REVIEWED",
-}
-
-export enum ProcessTriggerType {
-  MANUAL = "MANUAL",
-  SCHEDULED = "SCHEDULED",
-  API_MAPPING = "API_MAPPING",
-  WEBHOOK = "WEBHOOK",
-  API = "API",
-  SUB_PROCESS = "SUB_PROCESS",
-}
-
-export 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;
-}

package/src/utils/unmeshedCommonUtils.ts

@@ -1,13 +0,0 @@
-import { createHash } from "crypto";
-
-export class UnmeshedCommonUtils {
-  static createSecureHash(input: string): string {
-    try {
-      const hash = createHash("sha256");
-      hash.update(input, "utf8");
-      return hash.digest("hex");
-    } catch (e) {
-      throw new Error("Error creating hash");
-    }
-  }
-}