@unmeshed/sdk 1.0.9 → 1.0.11

package/dist/apiClient.js

@@ -1,89 +0,0 @@
-import axios from "axios";
-import { UnmeshedCommonUtils } from "./utils/unmeshedCommonUtils";
-export 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.create({
-            baseURL,
-            timeout,
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer client.sdk.${clientId}.${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) {
-        console.error("Error details:", {
-            message: error.message,
-            status: error.response?.status,
-            data: error.response?.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;
-    }
-}

package/dist/index.d.ts

@@ -1,21 +0,0 @@
-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<ApiCallType>;
-    runProcessAsync: (ProcessRequestData: ProcessRequestData) => Promise<ApiCallType>;
-    getProcessData: (processId: number) => Promise<ApiCallType>;
-    getStepData: (stepId: number | null) => Promise<ApiCallType>;
-    bulkTerminate: (processIds: number[], reason?: string) => Promise<ApiCallType>;
-    bulkResume: (processIds: number[]) => Promise<ApiCallType>;
-    bulkReviewed: (processIds: number[], reason?: string) => Promise<ApiCallType>;
-    rerun: (processId: number, clientId: string, version?: number) => Promise<ApiCallType>;
-    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,22 +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";
-export const apiClient = new ApiClient();
-const UnmeshedClient = {
-    initialize: (config) => apiClient.initialize(config),
-    runProcessSync,
-    runProcessAsync,
-    getProcessData,
-    getStepData,
-    bulkTerminate,
-    bulkResume,
-    bulkReviewed,
-    rerun,
-    searchProcessExecutions,
-    invokeApiMappingGet,
-    invokeApiMappingPost,
-    renewRegistration,
-    pollForWorkers,
-};
-export default UnmeshedClient;

package/dist/poller/pollerClientImpl.d.ts

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

package/dist/poller/pollerClientImpl.js

@@ -1,122 +0,0 @@
-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);
-        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) {
-            if (error.message === "Timed out") {
-                workerResponse = {
-                    ...workerResponse,
-                    output: {
-                        error: error.message,
-                    },
-                    status: StepStatus.TIMED_OUT,
-                };
-            }
-            else {
-                workerResponse = {
-                    ...workerResponse,
-                    output: {
-                        error: error.message,
-                    },
-                    status: 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

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

@@ -1,181 +0,0 @@
-import { apiClient } from "..";
-import { ApiCallType, } from "../types";
-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) {
-        throw new Error(`Error occurred while fetching step record: ${error.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) {
-        throw new Error(`Error occurred while terminating processes: ${error.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) {
-        throw new Error(`Error occurred while resuming processes: ${error.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) {
-        throw new Error(`Error occurred while marking processes as reviewed: ${error.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 (error.isAxiosError) {
-            throw new Error(`HTTP request error during rerun process: ${error.response?.status} - ${error.response?.data}`);
-        }
-        else {
-            throw new Error(`Unexpected error during rerun process: ${error.message}`);
-        }
-    }
-};
-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.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/registration/registrationClientImpl.d.ts

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

package/dist/registration/registrationClientImpl.js

@@ -1,17 +0,0 @@
-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/sample/sampleAPI.d.ts

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

package/dist/sample/sampleAPI.js

@@ -1,29 +0,0 @@
-"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/server.d.ts

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

package/dist/sample/server.js

@@ -1,9 +0,0 @@
-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/apiClient.d.ts

@@ -1,14 +0,0 @@
-import { ApiClientConfig, ApiResponse, ClientRequestConfig, QueryParams, RequestConfig } from "./types";
-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 | undefined;
-}

package/dist/src/apiClient.js

@@ -1,99 +0,0 @@
-import axios from "axios";
-import { UnmeshedCommonUtils } from "./utils/unmeshedCommonUtils";
-export class ApiClient {
-    constructor() {
-        this.axiosInstance = null;
-        this.clientId = undefined;
-    }
-    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.create({
-            baseURL,
-            timeout,
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer client.sdk.${clientId}.${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 {
-            // Assert that axiosInstance exists before using it
-            if (!this.axiosInstance) {
-                throw new Error("Axios instance is not initialized");
-            }
-            const response = await this.axiosInstance.request({
-                method,
-                url: endpoint,
-                params,
-                data,
-                ...config,
-            });
-            return {
-                data: response.data,
-                status: response.status,
-                headers: response.headers,
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                console.error("Request failed:", error.message);
-                throw this.handleError(error);
-            }
-            else {
-                console.error("Unexpected error:", error.message);
-                throw error;
-            }
-        }
-    }
-    handleError(error) {
-        console.error("Error details:", {
-            message: error.message,
-            status: error.response?.status,
-            data: error.response?.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;
-    }
-}

package/dist/src/index.d.ts

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