erpnext-queue-client 1.0.2

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+import { TypeOf, ZodTypeAny } from "zod";
+import { ERPNextQueueClientContructorOptions, ERPNextQueueType } from "./erpnext/model/ERPNextQueue";
+import { ERPNextRequestOptions } from "./erpnext/model/ERPNextRequest";
+import { erpnextRequests } from "./erpnext/erpnextRequests";
+/**
+ * @description Provide either a temporal client or connection details to create a new client
+ */
+export declare class ERPNextClient {
+    private client;
+    private credentials;
+    erpnext: ReturnType<typeof erpnextRequests>;
+    constructor(options: ERPNextQueueClientContructorOptions);
+    private tryConnect;
+    private createClient;
+    private getClient;
+    /**
+     * @description Execute an ERPNext request workflow, 0 is the highest priority, 5 is default
+     */
+    executeERPNextRequest<T extends ZodTypeAny, K extends ZodTypeAny>(requestName: string, options: ERPNextRequestOptions<T, K>, queue: ERPNextQueueType, priority?: number): Promise<TypeOf<T>>;
+    utils: {
+        decryptFromErpNext: (encryptedPassword: string) => string;
+        executeERPNextRequestWithoutTemporalQueue: <T extends ZodTypeAny, K extends ZodTypeAny>(options: ERPNextRequestOptions<T, K>) => Promise<TypeOf<T>>;
+        executeERPNextRequestDownloadFile: <T extends ZodTypeAny, K extends ZodTypeAny>(url: string) => Promise<Buffer<ArrayBufferLike>>;
+    };
+}

package/dist/client.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERPNextClient = void 0;
+const client_1 = require("@temporalio/client");
+const logger_1 = require("./utils/logger");
+const zodUtils_1 = require("./utils/zodUtils");
+const nanoid_1 = require("nanoid");
+const erpnextRequestWrapper_1 = require("./erpnext/erpnextRequestWrapper");
+const erpnextRequests_1 = require("./erpnext/erpnextRequests");
+const decryptFromErpNext_server_1 = require("./erpnext/decryptFromErpNext.server");
+const nanoid = (0, nanoid_1.customAlphabet)("1234567890", 4);
+/**
+ * @description Provide either a temporal client or connection details to create a new client
+ */
+class ERPNextClient {
+    constructor(options) {
+        this.utils = {
+            decryptFromErpNext: (encryptedPassword) => {
+                return (0, decryptFromErpNext_server_1.decryptFromErpNext)(this.credentials, encryptedPassword);
+            },
+            executeERPNextRequestWithoutTemporalQueue: (options) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.credentials)
+                    throw new Error("Direct API connection not possible. Please provide ERPNext API credentials.");
+                return yield (0, erpnextRequestWrapper_1.erpnextRequest)(this.credentials, options);
+            }),
+            executeERPNextRequestDownloadFile: (url) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.credentials)
+                    throw new Error("File download not possible. Please provide ERPNext API credentials.");
+                return yield (0, erpnextRequestWrapper_1.erpNextDownloadFile)(this.credentials, url);
+            }),
+        };
+        const { client, erpnextCredentials, temporalCredentials } = options;
+        // Optional: initialize with ERPNext credentials for direct ERPNext connection
+        if (erpnextCredentials)
+            this.credentials = erpnextCredentials;
+        // Use existing client or create a new one
+        if (client)
+            this.client = client;
+        else if (temporalCredentials.temporalHost)
+            this.createClient(temporalCredentials);
+        else
+            throw new Error("No client or connection details provided");
+        this.erpnext = (0, erpnextRequests_1.erpnextRequests)(this);
+    }
+    tryConnect(temporalHost, temporalCert, temporalKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield client_1.Connection.connect({
+                    address: temporalHost,
+                    tls: {
+                        clientCertPair: {
+                            crt: Buffer.from(temporalCert, "base64"),
+                            key: Buffer.from(temporalKey, "base64"),
+                        },
+                    },
+                });
+            }
+            catch (err) {
+                return undefined;
+            }
+        });
+    }
+    createClient(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.tryConnect(options.temporalHost, options.temporalCert, options.temporalKey);
+            this.client = new client_1.Client(Object.assign({ connection }, { namespace: options.temporalNamespace || "default" }));
+            return this.client;
+        });
+    }
+    getClient(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client && !options)
+                throw new Error("No client or connection details provided");
+            return this.client || (yield this.createClient(options));
+        });
+    }
+    /**
+     * @description Execute an ERPNext request workflow, 0 is the highest priority, 5 is default
+     */
+    executeERPNextRequest(requestName_1, options_1, queue_1) {
+        return __awaiter(this, arguments, void 0, function* (requestName, options, queue, priority = 5) {
+            if (process.env.NODE_ENV === "test")
+                return;
+            const runId = `${requestName}-${nanoid(4)}`;
+            const client = yield this.getClient();
+            console.log(`Enqueue to ERPNext Queue: ${options.uri || options.url}`);
+            const { inputValidationModel, responseValidationModel } = options, optionsWithoutValidation = __rest(options, ["inputValidationModel", "responseValidationModel"]);
+            if (options.body && inputValidationModel)
+                (0, zodUtils_1.validateData)(options.body, inputValidationModel);
+            const data = yield client.workflow
+                .execute("erpnextRequestWorkflow", {
+                args: [optionsWithoutValidation, priority],
+                taskQueue: priority < 5 ? `${queue}_priority` : queue, // add to priority queue if priority is 0-5
+                workflowId: runId,
+            })
+                .catch((err) => {
+                var _a, _b, _c;
+                // Try parsing the temporal error format
+                if ((_c = (_b = (_a = err === null || err === void 0 ? void 0 : err.cause) === null || _a === void 0 ? void 0 : _a.cause) === null || _b === void 0 ? void 0 : _b.failure) === null || _c === void 0 ? void 0 : _c.message) {
+                    const errorMessage = err.cause.cause.failure.message;
+                    let errorObject;
+                    try {
+                        errorObject = JSON.parse(errorMessage);
+                    }
+                    catch (e) {
+                        throw new Error(errorMessage);
+                    }
+                    if (errorObject)
+                        throw errorObject;
+                }
+                throw err;
+            });
+            const validatedData = responseValidationModel
+                ? (0, zodUtils_1.validateData)(data, responseValidationModel)
+                : data;
+            logger_1.lg.info(`Started workflow ${runId}`);
+            return validatedData;
+        });
+    }
+}
+exports.ERPNextClient = ERPNextClient;

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const getEnvVar: (varName: string) => string;
+type ConstantsMap<K extends string> = {
+    [key in K]: string;
+};
+export declare const constants: ConstantsMap<"DEBUG_MODE">;
+export {};

package/dist/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+/* -------------------------------------------------------------------------- */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = exports.getEnvVar = void 0;
+const getEnvVar = (varName) => {
+    const envVar = process.env[varName];
+    if (!envVar && !optionalConstants.includes(varName)) {
+        throw new Error(`ENV Var "${varName}" is not defined.`);
+    }
+    return envVar;
+};
+exports.getEnvVar = getEnvVar;
+class ConstantsManager {
+    constructor(constantNames) {
+        this.constants = {};
+        constantNames.forEach((c) => {
+            (0, exports.getEnvVar)(c);
+            Object.defineProperty(this.constants, c, {
+                get: () => (0, exports.getEnvVar)(c),
+            });
+        });
+        Object.freeze(this.constants);
+    }
+}
+const optionalConstants = ["DEBUG_MODE"];
+exports.constants = new ConstantsManager(["DEBUG_MODE"]).constants;

package/dist/erpnext/decryptFromErpNext.server.d.ts

@@ -0,0 +1,2 @@
+import { ERPNextCredentials } from "./model/ERPNextQueue";
+export declare function decryptFromErpNext(credentials: ERPNextCredentials, encryptedPassword: string): string;

package/dist/erpnext/decryptFromErpNext.server.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptFromErpNext = decryptFromErpNext;
+const fernet_server_1 = require("../utils/fernet.server");
+function decryptFromErpNext(credentials, encryptedPassword) {
+    if (!credentials.erpnextEncryptionKey)
+        throw new Error("ERPNext encryption key is not defined. Please specify it to use the decryptFromErpNext() function.");
+    const encyptionKey = credentials.erpnextEncryptionKey;
+    const encodedEncyptionKey = new fernet_server_1.Secret(encyptionKey);
+    var token = new fernet_server_1.Token({
+        secret: encodedEncyptionKey,
+        token: encryptedPassword,
+        ttl: 0,
+    });
+    const str = token.decode();
+    return str.toString();
+}

package/dist/erpnext/decryptFromErpNext.server.test.d.ts

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

package/dist/erpnext/decryptFromErpNext.server.test.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+describe("decryptFromErpNext", () => {
+    test("should decrypt password", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { utils: { decryptFromErpNext }, } = new client_1.ERPNextClient({
+            temporalCredentials: {
+                temporalHost: "temporalHost",
+            },
+            erpnextCredentials: {
+                erpnextApiKey: "erpnext",
+                erpnextApiSecret: "erpnextSecret",
+                erpnextUrl: "erpnextUrl",
+                erpnextEncryptionKey: "V4mf_rM7NX-0SW7OG5nCaAsFIkiBwcfE6-JQBoFxKZw", // Key for testing
+            },
+        });
+        const encryptedPassword = "gAAAAABjW77Rn3UP_3CZISSag2bsrq0huYiN5kavTd_2fUJUkcQd3tsrbsIbLk82TkqFKbwC1BnEP9iXKMQ-DrlIlLyIvZiwag==";
+        const decryptedPassword = decryptFromErpNext(encryptedPassword);
+        expect(decryptedPassword).toBe("12345");
+    }));
+});

package/dist/erpnext/erpnextRequestWrapper.d.ts

@@ -0,0 +1,5 @@
+import { type z } from "zod";
+import { ERPNextCredentials } from "./model/ERPNextQueue";
+import { ERPNextRequestOptions } from "./model/ERPNextRequest";
+export declare function erpnextRequest<T extends z.ZodTypeAny, K extends z.ZodTypeAny>(credentials: ERPNextCredentials, options: ERPNextRequestOptions<T, K>): Promise<z.TypeOf<T>>;
+export declare function erpNextDownloadFile(credentials: ERPNextCredentials, url: string): Promise<Buffer>;

package/dist/erpnext/erpnextRequestWrapper.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erpnextRequest = erpnextRequest;
+exports.erpNextDownloadFile = erpNextDownloadFile;
+const request_1 = require("../utils/request");
+const zodUtils_1 = require("../utils/zodUtils");
+const ERPNextResponse_1 = require("./model/ERPNextResponse");
+function getHeaders(credentials) {
+    return Object.assign({
+        Authorization: `token ${credentials.erpnextApiKey}:${credentials.erpnextApiSecret}`,
+        "Content-Type": "application/json",
+    }, (credentials.cloudflareAccessClientId &&
+        credentials.cloudflareAccessClientSecret
+        ? {
+            "CF-Access-Client-Id": credentials.cloudflareAccessClientId,
+            "CF-Access-Client-Secret": credentials.cloudflareAccessClientSecret,
+        }
+        : {}));
+}
+function erpnextRequest(credentials, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const baseUrl = options.methodName
+            ? `${credentials.erpnextUrl}/api/method/${options.methodName}`
+            : options.resourceName
+                ? `${credentials.erpnextUrl}/api/resource/${options.resourceName}`
+                : options.url;
+        if (!baseUrl)
+            throw new Error("No resource or method name provided");
+        const inputUrl = `${baseUrl.startsWith("/api/method") ? `${credentials.erpnextUrl}` : ""}${baseUrl}${options.resourceId ? `/${options.resourceId}` : ""}${options.params ? `${options.params}` : ""}`;
+        const url = options.resourceName && options.requestMethod === "GET"
+            ? inputUrl.includes("?")
+                ? `${inputUrl}&limit=0`
+                : !options.resourceId
+                    ? `${inputUrl}?limit=0`
+                    : inputUrl
+            : inputUrl;
+        const combinedHeaders = Object.assign(Object.assign({}, getHeaders(credentials)), (options.headers ? options.headers : {}));
+        // lgTemporal.info(`Temp url request check ${url}`);
+        const unvalidatedResult = yield (0, request_1.request)(Object.assign({ headers: combinedHeaders, url, method: options.requestMethod, inputValidationModel: options.inputValidationModel || false, responseValidationModel: false }, (options.body ? { body: options.body } : {}))).catch((err) => {
+            throw err.status
+                ? new Error(`Error ${err.status}: ${err.response &&
+                    typeof err.response === "object" &&
+                    "_server_messages" in err.response &&
+                    typeof err.response._server_messages === "string"
+                    ? JSON.parse(err.response._server_messages)
+                    : JSON.stringify(err.response)}`)
+                : err;
+        });
+        if (options.responseValidationModel === false)
+            return unvalidatedResult;
+        let returnValue;
+        if (options.methodName) {
+            const validatedResult = (0, zodUtils_1.validateData)(unvalidatedResult, ERPNextResponse_1.ERPNextMethodResponse);
+            returnValue = (0, zodUtils_1.validateData)(validatedResult.message, options.responseValidationModel);
+        }
+        else {
+            const validatedResult = (0, zodUtils_1.validateData)(unvalidatedResult, ERPNextResponse_1.ERPNextResourceResponse);
+            returnValue = (0, zodUtils_1.validateData)(validatedResult.data, options.responseValidationModel);
+        }
+        return returnValue;
+    });
+}
+function erpNextDownloadFile(credentials, url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isErpNextPrivateUrl = url.includes("/api/method");
+        const inputUrl = `${url.startsWith("/api/method") ? `${credentials.erpnextUrl}` : ""}${url}`;
+        let response = yield fetch(inputUrl, {
+            headers: isErpNextPrivateUrl ? getHeaders(credentials) : undefined,
+            redirect: isErpNextPrivateUrl ? "manual" : "follow",
+        });
+        if ((response === null || response === void 0 ? void 0 : response.status) === 302) {
+            const redirectUrl = response.headers.get("location");
+            if (!redirectUrl)
+                throw new Error("No redirect url");
+            response = yield fetch(redirectUrl);
+        }
+        if (!response.body)
+            throw new Error("No response body");
+        const buffer = yield response.arrayBuffer();
+        return Buffer.from(buffer);
+    });
+}