erpnext-queue-client 1.0.2

package/dist/utils/fernet.server.js

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hex = exports.Base64 = exports.Token = exports.Secret = exports.Buffer = exports.defaults = void 0;
+exports.setSecret = setSecret;
+exports.ArrayToHex = ArrayToHex;
+exports.timeBytes = timeBytes;
+exports.decode64toHex = decode64toHex;
+exports.createHmac = createHmac;
+exports.hexBits = hexBits;
+exports.urlsafe = urlsafe;
+/**
+ * This an es6 port of the library found here:
+ *    https://github.com/csquared/fernet.js
+ *
+ * This was ported due to issues with the global module scope and caused issues with rollup.js.
+ */
+// import URLBase64 from "urlsafe-base64"; // having issues finding buffer
+const buffer_1 = require("buffer");
+Object.defineProperty(exports, "Buffer", { enumerable: true, get: function () { return buffer_1.Buffer; } });
+const randombytes_1 = __importDefault(require("randombytes"));
+const aes_1 = __importDefault(require("crypto-js/aes"));
+const enc_utf8_1 = __importDefault(require("crypto-js/enc-utf8"));
+const enc_hex_1 = __importDefault(require("crypto-js/enc-hex"));
+exports.Hex = enc_hex_1.default;
+const enc_base64_1 = __importDefault(require("crypto-js/enc-base64"));
+exports.Base64 = enc_base64_1.default;
+const hmac_sha256_1 = __importDefault(require("crypto-js/hmac-sha256"));
+const defaults = {
+    ttl: 0,
+    versionHex: "80",
+    secret: undefined,
+};
+exports.defaults = defaults;
+const URLBase64 = {
+    encode(buffer) {
+        return buffer
+            .toString("base64")
+            .replace(/\+/g, "-") // Convert '+' to '-'
+            .replace(/\//g, "_") // Convert '/' to '_'
+            .replace(/=+$/, ""); // Remove ending '='
+    },
+    decode(base64) {
+        // Add removed at end '='
+        base64 += Array(5 - (base64.length % 4)).join("=");
+        base64 = base64
+            .replace(/-/g, "+") // Convert '-' to '+'
+            .replace(/_/g, "/"); // Convert '_' to '/'
+        return buffer_1.Buffer.from(base64, "base64");
+    },
+    validate(base64) {
+        return /^[A-Za-z0-9\-_]+$/.test(base64);
+    },
+};
+/**
+ * left pad a string for some hex conversions (changed to function rather than messing with the string prototype)
+ *
+ * @param {String} str - input string for padding
+ * @param {String} padString - pad string to prepend input string
+ * @param {Number} length - length of output padded string
+ * @return {String} the padded string
+ */
+function lpad(str, padString, length) {
+    while (str.length < length)
+        str = padString + str;
+    return str;
+}
+/**
+ * Makes a Base64 string a url-safe base64 slertring
+ * @param {String} string - input string to make url-safe
+ * @return {String} a url-safe base64 string
+ */
+function urlsafe(string) {
+    return string.replace(/\+/g, "-").replace(/\//g, "_"); //.replace(/=+$/, '')
+}
+/**
+ * parse a Hex string to an Int
+ * @param {String} hexString - a hexlified string
+ * @return {Number} resulting integer from input hex string
+ */
+const parseHex = (hexString) => {
+    return parseInt("0x" + hexString);
+};
+/**
+ * turn bits into number of chars in a hex string
+ * @param {Number} bits - input bits to convert to hex
+ * @return {Number} number of chars in hex string
+ */
+function hexBits(bits) {
+    return (bits / 8) * 2;
+}
+/**
+ * convert base64 string to hex string
+ * @param {String} string - input base64 string to hex
+ * @return {String} a hex string
+ */
+function decode64toHex(string) {
+    const s = URLBase64.decode(string.replace(/=+$/, ""));
+    return buffer_1.Buffer.from(s).toString("hex");
+}
+/**
+ * convert array to hex string
+ * @param {Number[]} array - iv array of integers
+ * @return {String} a hex string
+ */
+function ArrayToHex(array) {
+    let hex = "";
+    for (const _byte in array) {
+        hex += lpad(Number(_byte).toString(16), "0", 2);
+    }
+    return hex;
+}
+/**
+ * Creates a random hex string
+ * @param {Number} size - size of hex string
+ * @return {String} a hex string
+ */
+function randomHex(size) {
+    // return crypto.randomBytes(128/8).toString('hex');
+    return (0, randombytes_1.default)(128 / 8).toString("hex");
+}
+/**
+ * Will safely create an IV Array of integers
+ * @param {Number[]} [iv_array=null] - array of numbers for IV array.  If none passed in, a random hex will be created
+ * @return {String} a hex string
+ */
+function setIV(iv_array) {
+    return Array.isArray(iv_array) ? ArrayToHex(iv_array) : randomHex(128 / 8);
+}
+/**
+ * convert Time object or now into WordArray
+ * @param {Date} time - input Date object to convert to WordArray
+ * @return {Number[]} a word array
+ */
+function timeBytes(time) {
+    if (time) {
+        //@ts-ignore
+        time = time / 1000;
+    }
+    else {
+        //@ts-ignore
+        time = Math.round(new Date() / 1000);
+    }
+    //@ts-ignore
+    const hexTime = lpad(time.toString(16), "0", "16");
+    return enc_hex_1.default.parse(hexTime);
+}
+/**
+ * convenience function to create a new instance of a Secret() and sets it as the default for all future tokens
+ * @param {String} secret64 - base64 encoded secret string
+ * @return {Secret} a Secret
+ */
+function setSecret(secret64) {
+    defaults.secret = new Secret(secret64);
+    return defaults.secret;
+}
+/**
+ * Encrypts a message using AES
+ * @param {String} message - message to encrypt
+ * @param {String} encryptionKey - encryption key for AES
+ * @param {Number[]} iv - IV array
+ * @return {String} encrypted message
+ */
+function encryptMessage(message, encryptionKey, iv) {
+    const encrypted = aes_1.default.encrypt(message, encryptionKey, { iv });
+    return encrypted.ciphertext;
+}
+/**
+ * Decrypts an AES Encrypted message
+ * @param {String} cipherText - the encrypted message
+ * @param {String} encryptionKey - decryption key for AES
+ * @param {Number[]} iv - IV array
+ * @return {String} decrypted message
+ */
+function decryptMessage(cipherText, encryptionKey, iv) {
+    const encrypted = {
+        ciphertext: cipherText,
+        key: encryptionKey,
+        iv,
+    };
+    const decrypted = aes_1.default.decrypt(encrypted, encryptionKey, { iv });
+    return decrypted.toString(enc_utf8_1.default);
+}
+/**
+ * creates an encryption token
+ * @param {Number[]} signingKey - signing key for encyrption
+ * @param {Date} time - time stamp for verification
+ * @param {Number[]} iv - IV Array
+ * @param {String} cipherText - the cipher text
+ * @return {String} the url safe encrypted string
+ */
+function createToken(signingKey, time, iv, cipherText) {
+    const hmac = createHmac(signingKey, time, iv, cipherText);
+    let tokenWords = enc_hex_1.default.parse(defaults.versionHex);
+    for (let c of [time, iv, cipherText, hmac]) {
+        tokenWords = tokenWords.concat(c);
+    }
+    return urlsafe(tokenWords.toString(enc_base64_1.default));
+}
+/**
+ * Creates a SHA256 undigested byte string
+ * @param {Number[]} signingKey - signing key for encyrption
+ * @param {Date} time - time stamp for verification
+ * @param {Number[]} iv - IV Array
+ * @param {String} cipherText - the cipher text
+ * @return {String} an undigested byte string
+ */
+function createHmac(signingKey, time, iv, cipherText) {
+    let hmacWords = enc_hex_1.default.parse(defaults.versionHex);
+    for (let c of [time, iv, cipherText]) {
+        hmacWords = hmacWords.concat(c);
+    }
+    return (0, hmac_sha256_1.default)(hmacWords, signingKey);
+}
+/**
+ * Instance of a Secret to be used for the token encryption
+ */
+class Secret {
+    /**
+     * Creates a Secret to be used for the token encryption
+     * @param {String} secret64 - base64 encoded secret string
+     */
+    constructor(secret64) {
+        const secret = decode64toHex(secret64);
+        if (secret.length !== hexBits(256)) {
+            throw new Error("Secret must be 32 url-safe base64-encoded bytes.");
+        }
+        this.signingKeyHex = secret.slice(0, hexBits(128));
+        this.signingKey = enc_hex_1.default.parse(this.signingKeyHex);
+        this.encryptionKeyHex = secret.slice(hexBits(128));
+        this.encryptionKey = enc_hex_1.default.parse(this.encryptionKeyHex);
+    }
+}
+exports.Secret = Secret;
+/**
+ * Options for token object to perform encryption
+ * @typedef TokenOptions
+ * @property {Number} [ttl=60] - time to live in seconds
+ * @property {Secret} secret - Secret object to use for encryption/decryption
+ * @property {String} message - message to encrypt
+ * @property {String} cipherText - cipher text to decrypt
+ * @property {String} token - a token string
+ * @property {String} [version='80'] - version of the token
+ * @property {Number[]} iv - IV Array
+ */
+/**
+ * Token object to perform encryption/decryption
+ */
+class Token {
+    /**
+     * Token object to perform encryption/decryption
+     * @param {TokenOptions} opts - options for token initialization
+     */
+    constructor(opts) {
+        var _a, _b;
+        this.maxClockSkew = 60;
+        opts = opts || {};
+        this.secret = opts.secret || defaults.secret;
+        this.ttl = opts.ttl || defaults.ttl;
+        if (opts.ttl === 0)
+            this.ttl = 0;
+        this.message = (_a = opts.message) !== null && _a !== void 0 ? _a : "";
+        this.cipherText = opts.cipherText;
+        this.token = (_b = opts.token) !== null && _b !== void 0 ? _b : "";
+        this.version = opts.version || parseHex(defaults.versionHex);
+        this.optsIV = opts.iv;
+        // @ts-ignore
+        this.time = opts.time ? timeBytes(Date.parse(opts.time)) : timeBytes();
+        this.encoded = false;
+    }
+    /**
+     * converts token to string
+     * @return {String} to stringified token
+     */
+    toString() {
+        return this.encoded ? this.token : this.message;
+    }
+    /**
+     * Encrypts a message
+     * @param {String} message - message to encrypt
+     * @return {String} encoded token string
+     */
+    encode(message) {
+        if (!this.secret)
+            throw new Error("Secret not set");
+        this.encoded = true;
+        this.ivHex = setIV(this.optsIV);
+        this.iv = enc_hex_1.default.parse(this.ivHex); //if null will always be a fresh IV
+        this.message = message || this.message;
+        this.cipherText = encryptMessage(this.message, this.secret.encryptionKey, this.iv);
+        this.token = createToken(this.secret.signingKey, this.time, this.iv, this.cipherText);
+        return this.token;
+    }
+    /**
+     * Decrypts a token
+     * @param {String} token - token to decrypt
+     * @return {String} decoded message
+     */
+    decode(token) {
+        if (!this.secret)
+            throw new Error("Secret not set");
+        this.encoded = false;
+        this.token = token || this.token;
+        const tokenString = decode64toHex(this.token);
+        const versionOffset = hexBits(8);
+        const timeOffset = versionOffset + hexBits(64);
+        const ivOffset = timeOffset + hexBits(128);
+        const hmacOffset = tokenString.length - hexBits(256);
+        const timeInt = parseHex(tokenString.slice(versionOffset, timeOffset));
+        this.version = parseHex(tokenString.slice(0, versionOffset));
+        if (this.version != 128) {
+            throw new Error("Invalid version");
+        }
+        this.time = new Date(timeInt * 1000);
+        const currentTime = new Date();
+        // @ts-ignore
+        const timeDiff = (currentTime - this.time) / 1000;
+        if (this.ttl > 0 && timeDiff > this.ttl) {
+            throw new Error("Invalid Token: TTL");
+        }
+        // @ts-ignore
+        if (currentTime / 1000 + this.maxClockSkew < timeInt) {
+            throw new Error("far-future timestamp");
+        }
+        this.ivHex = tokenString.slice(timeOffset, ivOffset);
+        this.iv = enc_hex_1.default.parse(this.ivHex);
+        this.cipherTextHex = tokenString.slice(ivOffset, hmacOffset);
+        this.cipherText = enc_hex_1.default.parse(this.cipherTextHex);
+        this.hmacHex = tokenString.slice(hmacOffset);
+        const decodedHmac = createHmac(this.secret.signingKey, timeBytes(this.time), this.iv, this.cipherText);
+        const decodedHmacHex = decodedHmac.toString(enc_hex_1.default);
+        let accum = 0;
+        for (let i = 0; i < 64; i++) {
+            accum += decodedHmacHex.charCodeAt(i) ^ this.hmacHex.charCodeAt(i);
+        }
+        if (accum != 0)
+            throw new Error("Invalid Token: HMAC");
+        this.message = decryptMessage(this.cipherText, this.secret.encryptionKey, this.iv);
+        return this.message;
+    }
+}
+exports.Token = Token;

package/dist/utils/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const lg: {
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lg = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const winston_1 = require("winston");
+const utils_1 = require("./utils");
+const winstonInfoLogger = (0, winston_1.createLogger)({
+    transports: [
+        new winston_1.transports.Console({
+            level: "info",
+            format: winston_1.format.simple(),
+            handleExceptions: true,
+        }),
+        new winston_1.transports.Console({
+            level: "error",
+            format: winston_1.format.combine(winston_1.format.prettyPrint(), winston_1.format.colorize({ all: true })),
+            handleExceptions: true,
+        }),
+    ],
+    exitOnError: false,
+});
+const winstonErrorLogger = (0, winston_1.createLogger)({
+    transports: [
+        new winston_1.transports.Console({
+            level: "error",
+            format: winston_1.format.combine(winston_1.format.prettyPrint(), winston_1.format.colorize({ all: true })),
+            handleExceptions: true,
+        }),
+    ],
+    exitOnError: false,
+});
+const info = (...args) => {
+    winstonInfoLogger.info(args.filter(utils_1.isDefined));
+};
+const warn = (...args) => {
+    winstonInfoLogger.warn(args.filter(utils_1.isDefined));
+};
+const error = (...args) => {
+    winstonErrorLogger.error(args.filter(utils_1.isDefined));
+};
+exports.lg = {
+    info,
+    warn,
+    error,
+};

package/dist/utils/request.d.ts

@@ -0,0 +1,28 @@
+import type { z, ZodTypeAny } from "zod";
+export interface RequestOptions<T extends ZodTypeAny, K extends ZodTypeAny> {
+    url: string;
+    headers?: RequestInit["headers"];
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    responseValidationModel: T | false;
+    inputValidationModel: K | false;
+    body?: z.TypeOf<K>;
+    credentials?: RequestInit["credentials"];
+    isFormData?: boolean;
+}
+export interface RequestResponse {
+    status: number;
+    requestUrl: string;
+    statusText: string;
+    responseHeaders: Headers;
+    response: Record<string, unknown> | string;
+}
+export declare class RequestError extends Error {
+    status: number;
+    requestUrl: string;
+    statusText: string;
+    responseHeaders: Headers;
+    response: Record<string, unknown> | string;
+    constructor({ status, requestUrl, statusText, responseHeaders, response, }: RequestResponse);
+    toJSON(): Record<string, unknown>;
+}
+export declare function request<T extends ZodTypeAny, K extends ZodTypeAny>(options: RequestOptions<T, K>): Promise<z.infer<T>>;

package/dist/utils/request.js

@@ -0,0 +1,107 @@
+"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.RequestError = void 0;
+exports.request = request;
+const zodUtils_1 = require("./zodUtils");
+const logger_1 = require("./logger");
+class RequestError extends Error {
+    constructor({ status, requestUrl, statusText, responseHeaders, response, }) {
+        super(`Request failed with status ${status}: ${statusText} for URL ${requestUrl}`); // Call the parent `Error` constructor with the message
+        // Manually set the prototype to ensure `instanceof` works
+        Object.setPrototypeOf(this, RequestError.prototype);
+        this.name = "RequestError"; // Set the error name explicitly
+        this.status = status;
+        this.requestUrl = requestUrl;
+        this.statusText = statusText;
+        this.responseHeaders = responseHeaders; // Serialize headers as raw object
+        this.response = response;
+        // Attach the preserved stack trace if it was passed
+        Error.captureStackTrace(this, RequestError);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            requestUrl: this.requestUrl,
+            statusText: this.statusText,
+            responseHeaders: this.responseHeaders,
+            response: this.response,
+            responseJson: JSON.stringify(this.response, null, 2),
+        };
+    }
+}
+exports.RequestError = RequestError;
+function request(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const _c = options || {}, { body, url, inputValidationModel, responseValidationModel } = _c, requestOptions = __rest(_c, ["body", "url", "inputValidationModel", "responseValidationModel"]);
+        // Validate the request body
+        const validatedBody = inputValidationModel
+            ? (0, zodUtils_1.validateData)(body, inputValidationModel)
+            : body;
+        const contentType = options.headers &&
+            "Content-Type" in options.headers &&
+            ((_a = options.headers) === null || _a === void 0 ? void 0 : _a["Content-Type"])
+            ? (_b = options.headers) === null || _b === void 0 ? void 0 : _b["Content-Type"]
+            : undefined;
+        const stringifiedBody = options.method !== "GET" &&
+            contentType !== "text/xml" &&
+            contentType !== "application/xml" &&
+            contentType !== "application/x-www-form-urlencoded"
+            ? JSON.stringify(validatedBody)
+            : undefined;
+        const convertedOptions = Object.assign(Object.assign({}, requestOptions), (options.method !== "GET"
+            ? { body: stringifiedBody !== null && stringifiedBody !== void 0 ? stringifiedBody : validatedBody }
+            : {}));
+        // Log requests
+        logger_1.lg.info(`${options.method}${url}`);
+        // Wrap fetch
+        const response = yield fetch(url, convertedOptions);
+        const { status, url: requestUrl, statusText, ok } = response;
+        const textResult = yield response.text();
+        let finalResult;
+        try {
+            finalResult = JSON.parse(textResult);
+        }
+        catch (err) {
+            finalResult = textResult;
+        }
+        // Reject promise when status is expected or unexpected error. Allows use of try/catch to catch http errors
+        if (!ok) {
+            logger_1.lg.error(`Error in request to ${requestUrl} with status text ${statusText}`, JSON.stringify(finalResult, null, 2));
+            throw new RequestError({
+                status,
+                requestUrl,
+                statusText,
+                responseHeaders: response === null || response === void 0 ? void 0 : response.headers,
+                response: finalResult,
+            });
+        }
+        // Validate the response body
+        const validatedResult = responseValidationModel
+            ? (0, zodUtils_1.validateData)(finalResult, responseValidationModel)
+            : finalResult;
+        return validatedResult;
+    });
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function addDays(date: string | number | Date, days: number): Date;
+export declare function addMinutes(date: Date, minutes: number): Date;
+export declare function timeout(ms: number): Promise<void>;
+export declare function isDefined<T>(value: T | null | undefined): value is T;

package/dist/utils/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDays = addDays;
+exports.addMinutes = addMinutes;
+exports.timeout = timeout;
+exports.isDefined = isDefined;
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setUTCDate(result.getUTCDate() + days);
+    return result;
+}
+function addMinutes(date, minutes) {
+    const result = new Date(date);
+    result.setUTCMinutes(result.getUTCMinutes() + minutes);
+    return result;
+}
+// async await version of setTimeout
+function timeout(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function isDefined(value) {
+    return value !== null && value !== undefined;
+}

package/dist/utils/zodUtils.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function validateData<T extends z.ZodTypeAny>(data: unknown, ValidationModel: T): z.infer<T>;

package/dist/utils/zodUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateData = validateData;
+const constants_1 = require("../constants");
+function validateData(data, ValidationModel) {
+    if (!ValidationModel.description)
+        throw new Error("ValidationModel.description is required");
+    const validationResult = ValidationModel.safeParse(data);
+    if (!validationResult.success) {
+        throw {
+            message: `Validation error in model ${ValidationModel.description}`,
+            error: validationResult.error,
+            input: constants_1.constants.DEBUG_MODE === "true" ? data : "set DEBUG_MODE to true to see the input",
+        };
+    }
+    return validationResult.data;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "erpnext-queue-client",
+  "description": "Client to setup jobs in the temporal queue for processing ERPNext requests called \"erpnext-queue\"",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "dotenv -c test vitest",
+    "build": "tsc",
+    "release": "npm run build && npm publish"
+  },
+  "author": "Jonathan Laukenmann",
+  "license": "ISC",
+  "dependencies": {
+    "@temporalio/client": "^1.11.3",
+    "crypto-js": "^4.2.0",
+    "dotenv": "^16.4.7",
+    "dotenv-cli": "^8.0.0",
+    "lodash": "^4.17.21",
+    "nanoid": "^3.3.7",
+    "randombytes": "^2.1.0",
+    "winston": "^3.15.0",
+    "zod": "^3.23.8"
+  },
+  "version": "1.0.2",
+  "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}