@unmeshed/sdk 1.0.8 → 1.0.10

package/dist/src/poller/pollerClientImpl.js

@@ -0,0 +1,126 @@
+import { apiClient } from "..";
+import { StepStatus, } from "../types";
+async function registerPolling(data) {
+    const attempt = async () => {
+        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) {
+    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) {
+    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) {
+    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);
+        if (!associatedWorker) {
+            throw Error(`No worker found for ${polledWorker.stepName} ${polledWorker.stepNamespace}`);
+        }
+        let workerResponse = {
+            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) {
+            const err = 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/dist/src/process/processClientImpl.d.ts

@@ -0,0 +1,12 @@
+import { ApiCallType, ProcessActionResponseData, ProcessData, ProcessRequestData, ProcessSearchRequest, 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/src/process/processClientImpl.js

@@ -0,0 +1,187 @@
+import { apiClient } from "..";
+import { ApiCallType, } from "../types";
+import { isAxiosError } from "axios";
+const RUN_PROCESS_REQUEST_URL = "api/process/";
+export const runProcessSync = async (ProcessRequestData) => {
+    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) => {
+    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) => {
+    if (processId == null) {
+        throw new Error("Process ID cannot be null");
+    }
+    try {
+        const response = await apiClient.get(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) => {
+    if (stepId === null || stepId === undefined) {
+        throw new Error("Step ID cannot be null or undefined");
+    }
+    try {
+        const response = await apiClient.get(RUN_PROCESS_REQUEST_URL + "stepContext/" + stepId);
+        return response.data;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Error occurred while fetching step record: ${err.message || error}`);
+    }
+};
+export const bulkTerminate = async (processIds, reason) => {
+    try {
+        const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "bulkTerminate", {
+            params: { reason },
+            data: processIds,
+        });
+        return response.data;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Error occurred while terminating processes: ${err.message || error}`);
+    }
+};
+export const bulkResume = async (processIds) => {
+    try {
+        const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "bulkResume", {
+            data: processIds,
+        });
+        return response.data;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Error occurred while resuming processes: ${err.message || error}`);
+    }
+};
+export const bulkReviewed = async (processIds, reason) => {
+    try {
+        const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "bulkReviewed", {
+            data: processIds,
+            params: { reason },
+        });
+        return response.data;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Error occurred while marking processes as reviewed: ${err.message || error}`);
+    }
+};
+export const rerun = async (processId, clientId, version) => {
+    const params = {
+        clientId,
+        processId,
+    };
+    if (version !== undefined) {
+        params["version"] = version;
+    }
+    try {
+        const response = await apiClient.post(RUN_PROCESS_REQUEST_URL + "rerun", {
+            params,
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (isAxiosError(error)) {
+            throw new Error(`HTTP request error during rerun process: ${error.response?.status} - ${error.response?.data}`);
+        }
+        else {
+            const err = error;
+            throw new Error(`Unexpected error during rerun process: ${err.message || err}`);
+        }
+    }
+};
+export 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 || 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, id, correlationId, 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, input, id, correlationId, apiCallType = ApiCallType.ASYNC) => {
+    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/dist/src/registration/registrationClientImpl.d.ts

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

package/dist/src/registration/registrationClientImpl.js

@@ -0,0 +1,17 @@
+import { apiClient } from "..";
+export const renewRegistration = async () => {
+    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/dist/src/sample/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/sample/server.js

@@ -0,0 +1,9 @@
+import { initialize } from "../index";
+import { getProcessData } from "../process/processClientImpl";
+initialize({
+    baseUrl: "https://perfdemo.unmeshed.com",
+    clientId: "e1208b04-e308-4976-b236-074a82b0ecbb",
+    authToken: "8R06KsNUqBN4b67jcN0W",
+    port: "443",
+});
+getProcessData(27100448).then(result => console.log(JSON.stringify(result, null, 2)));

package/dist/src/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 {};