@dotdev/harmony-sdk 1.0.1

package/dist/helpers/index.spec.js

@@ -0,0 +1,147 @@
+import axios from "axios";
+import { ApiHelper, checkParamLimits, Utils } from ".";
+import { ServiceAlias } from "../modules/shared/types";
+// Increase timeout due to Harmony API having long response time
+jest.setTimeout(999999);
+jest.mock("axios");
+const mAxios = axios;
+describe("ApiHelper", () => {
+    test("ApiHelper.sendSoapRequest", async () => {
+        const endpoint = "/StockLookupService/StockLookupService";
+        const sessionId = "test-session-id";
+        const requestBody = `
+			<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/" xmlns:stk="http://stk.ws.fbsaust.com.au">
+				<S:Header>
+						<stk:SessionId>${sessionId}</stk:SessionId>
+				</S:Header>
+				<S:Body>
+						<stk:StockClassificationLookup>
+						<SearchType>STK00</SearchType>
+						</stk:StockClassificationLookup>
+				</S:Body>
+			</S:Envelope>
+		`;
+        mAxios.post.mockResolvedValueOnce({
+            data: `
+				<?xml version='1.0' encoding='UTF-8'?>
+				<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+						<S:Body>
+								<ns2:StockClassificationLookupResponse xmlns:ns2="http://stk.ws.fbsaust.com.au">
+										<StockClassification>
+												<code>BACK</code>
+												<description>TEST</description>
+										</StockClassification>
+								</ns2:StockClassificationLookupResponse>
+						</S:Body>
+				</S:Envelope>
+			`,
+        });
+        const response = await ApiHelper.sendSoapRequest(endpoint, mAxios, requestBody);
+        expect(response["ns2:StockClassificationLookupResponse"][0]
+            .StockClassification).toEqual([
+            {
+                code: ["BACK"],
+                description: ["TEST"],
+            },
+        ]);
+    });
+    test("createServiceRequestBody should return correct SOAP request body", () => {
+        const expected = `
+			<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/" xmlns:stk="http://stk.ws.fbsaust.com.au">
+					<S:Header>
+						<stk:SessionId>ABC</stk:SessionId>
+					</S:Header>
+					<S:Body>
+						<stk:StockClassificationLookup>
+							<SearchType>STK99</SearchType>
+						</stk:StockClassificationLookup>
+					</S:Body>
+			</S:Envelope>
+		`;
+        const actual = ApiHelper.createServiceRequestBody("StockClassificationLookup", "ABC", ServiceAlias.STOCK_LOOKUP, "<SearchType>STK99</SearchType>");
+        expect(Utils.removeEmptySpaces(actual)).toEqual(Utils.removeEmptySpaces(expected));
+    });
+});
+describe("Other functions", () => {
+    test("checkParamLimit", () => {
+        const params = {
+            param1: 123,
+            param2: "abc",
+            param3: true,
+        };
+        // Matching param limit
+        const matchedParamLimit = {
+            param1: 3,
+            param2: 3,
+            param3: (val) => typeof val === "boolean" && val === true,
+        };
+        expect(checkParamLimits(params, matchedParamLimit)).toBe(true);
+        // Exceeded param limit
+        const exceededParamLimit = {
+            param1: 3,
+            param2: 2,
+            param3: (val) => typeof val === "boolean" && val === true,
+        };
+        expect(() => checkParamLimits(params, exceededParamLimit)).toThrow(`Provided value for "param2" exceeds limit of 2`);
+        // Limit using function return false
+        const falseParamLimit = {
+            param1: 3,
+            param2: 3,
+            param3: (val) => val === false,
+        };
+        expect(() => checkParamLimits(params, falseParamLimit)).toThrow(`Invalid value for parameter "param3": true`);
+    });
+    test("checkParamLimit with enum", () => {
+        let TestEnum;
+        (function (TestEnum) {
+            TestEnum[TestEnum["A"] = 0] = "A";
+            TestEnum[TestEnum["B"] = 1] = "B";
+        })(TestEnum || (TestEnum = {}));
+        const params = {
+            param1: TestEnum.A,
+        };
+        const wrongParams = {
+            param1: "C",
+        };
+        // Matching param limit
+        const matchedParamLimit = {
+            param1: (val) => Object.values(TestEnum).includes(val),
+        };
+        expect(checkParamLimits(params, matchedParamLimit)).toBe(true);
+        expect(() => checkParamLimits(wrongParams, matchedParamLimit)).toThrow(`Invalid value for parameter "param1": C`);
+    });
+    test("checkParamLimit with no limit", () => {
+        const params = {
+            param1: "asdf",
+        };
+        // Matching param limit
+        const matchedParamLimit = {};
+        expect(checkParamLimits(params, matchedParamLimit)).toBe(true);
+    });
+});
+describe("parseRequestError", () => {
+    it("should handle error correctly and return the error string", async () => {
+        const errResp = `
+			<?xml version='1.0' encoding='UTF-8'?>
+			<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+					<S:Body>
+							<S:Fault xmlns:ns4="http://www.w3.org/2003/05/soap-envelope">
+									<faultcode>S:Server</faultcode>
+									<faultstring>Failed Test Request</faultstring>
+									<detail>
+											<ns2:ServiceFault xmlns:ns2="http://pos.ws.fbsaust.com.au">
+													<errorDetails>[204-104-2408071537-0000851206]  (Invalid value)</errorDetails>
+											</ns2:ServiceFault>
+									</detail>
+							</S:Fault>
+					</S:Body>
+			</S:Envelope>
+		`;
+        const expected = {
+            code: "S:Server",
+            name: "Failed Test Request",
+            message: "[204-104-2408071537-0000851206]  (Invalid value)",
+        };
+        expect(await ApiHelper.parseHarmonyErrorResponse(errResp)).toEqual(expected);
+    });
+});

package/dist/helpers/mapper.d.ts

@@ -0,0 +1,2 @@
+import { OptionalStockQueryParams, OptionalStockRequestBody } from "../modules/shared/types";
+export declare function mapOptionalStockQueryParams(src: OptionalStockQueryParams): OptionalStockRequestBody;

package/dist/helpers/mapper.js

@@ -0,0 +1,28 @@
+import { OptionalStockRequestBody, } from "../modules/shared/types";
+export function mapOptionalStockQueryParams(src) {
+    return new OptionalStockRequestBody({
+        StockCategoryFr: src?.stockCategoryFr ?? "",
+        StockCategoryTo: src?.stockCategoryTo ?? "",
+        StockClassFr1: src?.stockClassFr1 ?? "",
+        StockClassTo1: src?.stockClassTo1 ?? "",
+        StockClassFr2: src?.stockClassFr2 ?? "",
+        StockClassTo2: src?.stockClassTo2 ?? "",
+        StockClassFr3: src?.stockClassFr3 ?? "",
+        StockClassTo3: src?.stockClassTo3 ?? "",
+        StockExtraClassFr1: src?.stockExtraClassFr1 ?? "",
+        StockExtraClassTo1: src?.stockExtraClassTo1 ?? "",
+        StockExtraClassFr2: src?.stockExtraClassFr2 ?? "",
+        StockExtraClassTo2: src?.stockExtraClassTo2 ?? "",
+        StockExtraClassFr3: src?.stockExtraClassFr3 ?? "",
+        StockExtraClassTo3: src?.stockExtraClassTo3 ?? "",
+        StockExtraClassFr4: src?.stockExtraClassFr4 ?? "",
+        StockExtraClassTo4: src?.stockExtraClassTo4 ?? "",
+        StockExtraClassFr5: src?.stockExtraClassFr5 ?? "",
+        StockExtraClassTo5: src?.stockExtraClassTo5 ?? "",
+        SysModTimeFr: src?.sysModTimeFr ?? "",
+        SysModTimeTo: src?.sysModTimeTo ?? "",
+        AlternateNamekeyFr: src?.alternateNamekeyFr ?? "",
+        AlternateNamekeyTo: src?.alternateNamekeyTo ?? "",
+        StockActive: src?.stockActive?.map(String)?.join("") ?? "",
+    });
+}

package/dist/helpers/utils.d.ts

@@ -0,0 +1,71 @@
+export declare abstract class Utils {
+    /**
+     * Check if an object is an empty array or not an array
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is an empty array
+     */
+    static isEmptyArray(obj: any): boolean;
+    /**
+     * Check if an object is a non-empty array.
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is a non-empty array
+     */
+    static nonEmptyArray(obj: any): boolean;
+    /**
+     * Chcek if an object is an empty string or not a string
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is an empty string
+     */
+    static isEmptyString(obj: any): boolean;
+    /**
+     * Check if an object is a non-empty string.
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is a non-empty string
+     */
+    static nonEmptyString(obj: any): boolean;
+    /**
+     * Convert a value to a number.
+     *
+     * @static
+     * @param {*} obj object to convert to a number
+     * @returns {number} the converted number
+     */
+    static toNumber(obj: any): number;
+    static checkMaxStringLength(str: any, length: number, propName?: string): boolean;
+    /**
+     * Remove all empty spaces within a string, including new lines and tabs...
+     *
+     * @static
+     * @param {string} str to remove empty spaces from
+     * @returns {string} string with empty spaces removed
+     */
+    static removeEmptySpaces(str: string): string;
+    static isXmlEqualJson(xml: string, json: any): Promise<boolean>;
+    /**
+     * Recursively convert an object into xml format
+     *
+     * @static
+     * @param {*} obj
+     * @returns {string}
+     */
+    static toXml(obj: object, parent?: string): string;
+    static deleteUndefinedProps(obj: any): any;
+    static deleteEmptyProps(obj: any): any;
+    /**
+     * Returns first element of an array.
+     * Responses extracted from XML have all properties in the format of arrays of 1 element. This is used to extract value out of those properties
+     *
+     * @static
+     * @param {*} prop property array to extract
+     * @returns {*} first value in the array
+     */
+    static getFirst(prop: any): string;
+}

package/dist/helpers/utils.js

@@ -0,0 +1,133 @@
+import { promisify } from "util";
+import { parseString } from "xml2js";
+const parseXml = promisify(parseString);
+export class Utils {
+    /**
+     * Check if an object is an empty array or not an array
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is an empty array
+     */
+    static isEmptyArray(obj) {
+        return !Utils.nonEmptyArray(obj);
+    }
+    /**
+     * Check if an object is a non-empty array.
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is a non-empty array
+     */
+    static nonEmptyArray(obj) {
+        return Array.isArray(obj) && obj.length > 0;
+    }
+    /**
+     * Chcek if an object is an empty string or not a string
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is an empty string
+     */
+    static isEmptyString(obj) {
+        return !Utils.nonEmptyString(obj);
+    }
+    /**
+     * Check if an object is a non-empty string.
+     *
+     * @static
+     * @param {*} obj object to check
+     * @returns {boolean} true if object is a non-empty string
+     */
+    static nonEmptyString(obj) {
+        return typeof obj === "string" && obj.trim() !== "";
+    }
+    /**
+     * Convert a value to a number.
+     *
+     * @static
+     * @param {*} obj object to convert to a number
+     * @returns {number} the converted number
+     */
+    static toNumber(obj) {
+        const num = Number(obj);
+        if (isNaN(num))
+            throw new Error(`Provided value [${obj}] is not a number.`);
+        return num;
+    }
+    static checkMaxStringLength(str, length, propName = "property") {
+        if (!(typeof str === "string" && str.length <= length))
+            throw new Error(`Provided ${propName} exceeds maximum length of ${length} characters.`);
+        return true;
+    }
+    /**
+     * Remove all empty spaces within a string, including new lines and tabs...
+     *
+     * @static
+     * @param {string} str to remove empty spaces from
+     * @returns {string} string with empty spaces removed
+     */
+    static removeEmptySpaces(str) {
+        return str.replace(/\s/g, "");
+    }
+    static async isXmlEqualJson(xml, json) {
+        const result = (await parseXml(`<result>${xml}</result>`))["result"];
+        // Test that each key value pair matches the expected
+        for (const k in result) {
+            const val = result[k][0];
+            if (json[k] !== val)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Recursively convert an object into xml format
+     *
+     * @static
+     * @param {*} obj
+     * @returns {string}
+     */
+    static toXml(obj, parent) {
+        if (obj == null)
+            return "";
+        let str = "";
+        const open = parent ? `<${parent}>` : "";
+        const close = parent ? `</${parent}>` : "";
+        if (Array.isArray(obj)) {
+            str += obj.map((o) => open + Utils.toXml(o) + close).join("");
+        }
+        else if (typeof obj === "object") {
+            let valStr = "";
+            for (const k in obj) {
+                const val = obj[k];
+                if (!(val == null)) {
+                    valStr += `${Utils.toXml(val, k)}`;
+                }
+            }
+            str += open + valStr + close;
+        }
+        else {
+            str += open + obj + close;
+        }
+        return str;
+    }
+    static deleteUndefinedProps(obj) {
+        Object.keys(obj).forEach((key) => obj[key] === undefined && delete obj[key]);
+        return obj;
+    }
+    static deleteEmptyProps(obj) {
+        Object.keys(obj).forEach((key) => [undefined, null, ""].includes(obj[key]) && delete obj[key]);
+        return obj;
+    }
+    /**
+     * Returns first element of an array.
+     * Responses extracted from XML have all properties in the format of arrays of 1 element. This is used to extract value out of those properties
+     *
+     * @static
+     * @param {*} prop property array to extract
+     * @returns {*} first value in the array
+     */
+    static getFirst(prop) {
+        return (prop ?? [])[0];
+    }
+}

package/dist/helpers/utils.spec.d.ts

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

package/dist/helpers/utils.spec.js

@@ -0,0 +1,96 @@
+import { Utils } from "./utils";
+describe("Utils", () => {
+    test("isEmptyArray", () => {
+        expect.assertions(7);
+        const nonEmpty = [1, 2, 3];
+        const nonEmptyStr = ["1", "2", "3"];
+        expect(Utils.isEmptyArray(nonEmpty)).toBe(false);
+        expect(Utils.isEmptyArray(nonEmptyStr)).toBe(false);
+        expect(Utils.isEmptyArray([])).toBe(true);
+        expect(Utils.isEmptyArray("")).toBe(true);
+        expect(Utils.isEmptyArray("asadf")).toBe(true);
+        expect(Utils.isEmptyArray(null)).toBe(true);
+        expect(Utils.isEmptyArray(undefined)).toBe(true);
+    });
+    test("isEmptyString", () => {
+        expect.assertions(6);
+        const nonEmpty = "test";
+        expect(Utils.isEmptyString(nonEmpty)).toBe(false);
+        expect(Utils.isEmptyString([])).toBe(true);
+        expect(Utils.isEmptyString(["1", "2", "3"])).toBe(true);
+        expect(Utils.isEmptyString("")).toBe(true);
+        expect(Utils.isEmptyString(null)).toBe(true);
+        expect(Utils.isEmptyString(undefined)).toBe(true);
+    });
+    test("toNumber", () => {
+        const invalidValues = [undefined, "abc", "123abc", {}, "*&^*"];
+        for (const i of invalidValues) {
+            expect(() => Utils.toNumber(i)).toThrow(`Provided value [${i}] is not a number.`);
+        }
+        expect(Utils.toNumber("123")).toBe(123);
+        expect(Utils.toNumber("123.45")).toBe(123.45);
+        expect(Utils.toNumber(true)).toBe(1);
+        expect(Utils.toNumber(false)).toBe(0);
+        expect(Utils.toNumber("")).toBe(0);
+        expect(Utils.toNumber(null)).toBe(0);
+    });
+    test("toXml should convert to XML string successfully", () => {
+        const obj = {
+            name: "John Doe",
+            age: 30,
+            city: "New York",
+            hobbies: ["reading", "painting"],
+            address: {
+                street: "123 Main St",
+                city: "New York",
+                state: "NY",
+                zip: "10001",
+            },
+            count: 0,
+            nullable: null,
+        };
+        const expectedXml = `
+			<name>John Doe</name>
+     <age>30</age>
+     <city>New York</city>
+     <hobbies>reading</hobbies>
+     <hobbies>painting</hobbies>
+     <address>
+         <street>123 Main St</street>
+         <city>New York</city>
+         <state>NY</state>
+         <zip>10001</zip>
+     </address>
+		 <count>0</count>
+		`;
+        expect(Utils.removeEmptySpaces(Utils.toXml(obj))).toEqual(Utils.removeEmptySpaces(expectedXml));
+    });
+    test("deleteUndefinedProps() should remove undefined properties", () => {
+        const obj = {
+            "1": true,
+            "2": "test",
+            "3": undefined,
+            "4": null,
+        };
+        Utils.deleteUndefinedProps(obj);
+        expect(obj).toEqual({
+            "1": true,
+            "2": "test",
+            "4": null,
+        });
+    });
+    test("deleteEmptyProps() should remove all empty properties", () => {
+        const obj = {
+            "1": true,
+            "2": "test",
+            "3": undefined,
+            "4": null,
+            "5": "",
+        };
+        Utils.deleteEmptyProps(obj);
+        expect(obj).toEqual({
+            "1": true,
+            "2": "test",
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./errors";
+export * from "./HarmonyAPI";
+export * from "./helpers";
+export * from "./modules";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./errors";
+export * from "./HarmonyAPI";
+export * from "./helpers";
+export * from "./modules";
+export * from "./types";

package/dist/modules/auth/auth.module.d.ts

@@ -0,0 +1,7 @@
+import { AxiosInstance } from "axios";
+import { AuthenticationToken } from "./types";
+export declare class AuthModule {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    authenticate(authToken: AuthenticationToken): Promise<string>;
+}

package/dist/modules/auth/auth.module.js

@@ -0,0 +1,42 @@
+import { AuthenticationError } from "../../errors";
+import { ApiHelper } from "../../helpers";
+export class AuthModule {
+    axiosInstance;
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    async authenticate(authToken) {
+        // @todo: TBC whether using `xmlbuilder` or template string
+        const authHeader = `
+      <ns2:AuthenticationToken xmlns:ns2="http://auth.ws.fbsaust.com.au" xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+        <username>${authToken.username}</username>
+        <method>${authToken.method}</method>
+        <password>${authToken.password}</password>
+        <timeout>${authToken.timeout}${authToken.timeoutUnit}</timeout>
+      </ns2:AuthenticationToken>
+    `;
+        const loginBody = '<ns2:Login xmlns:ns2="http://auth.ws.fbsaust.com.au"/>';
+        const soapEnvelope = `
+      <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+        <S:Header>${authHeader}</S:Header>
+        <S:Body>${loginBody}</S:Body>
+      </S:Envelope>
+    `;
+        try {
+            const response = await ApiHelper.sendSoapRequest("/AuthenticationService/AuthenticationService", this.axiosInstance, soapEnvelope);
+            const token = response["ns2:LoginResponse"][0]["token"][0];
+            if (!token) {
+                throw new AuthenticationError("No token received in the authentication response");
+            }
+            return token;
+        }
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                throw error;
+            }
+            else {
+                throw new AuthenticationError(`An unexpected error occurred: ${error.message}`);
+            }
+        }
+    }
+}

package/dist/modules/auth/auth.module.spec.d.ts

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

package/dist/modules/auth/auth.module.spec.js

@@ -0,0 +1,55 @@
+import axios from "axios";
+import { ApiHelper, Utils } from "../../helpers";
+import { AuthModule } from "./auth.module";
+jest.mock("axios");
+const mAxios = axios;
+const sessionId = ""; // process.env.SESSION_ID as string;
+describe("AuthModule", () => {
+    let authModule;
+    beforeAll(() => {
+        authModule = new AuthModule(mAxios);
+    });
+    test("authenticate successfully", async () => {
+        const mockedSendApiRequest = jest.spyOn(ApiHelper, "sendSoapRequest");
+        const authToken = {
+            username: "test-username",
+            password: "test-password",
+            method: "Basic",
+            timeout: 365,
+            timeoutUnit: "day",
+        };
+        const mockedToken = "CI03GWHZzXO0VJQ6JSLJoPwWijXTIPilphKvlLhLHcjDQ3yrr6eJeTK6wxDb8XZb";
+        const mockedResponse = {
+            data: `
+			<?xml version='1.0' encoding='UTF-8'?>
+			<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+					<S:Body>
+							<ns2:LoginResponse xmlns:ns2="http://auth.ws.fbsaust.com.au">
+									<token>${mockedToken}</token>
+							</ns2:LoginResponse>
+					</S:Body>
+			</S:Envelope>
+			`,
+        };
+        mAxios.post.mockResolvedValueOnce(mockedResponse);
+        const token = await authModule.authenticate(authToken);
+        expect(mockedSendApiRequest).toHaveBeenCalled();
+        expect(mAxios.post).toHaveBeenCalled();
+        expect(Utils.removeEmptySpaces(mAxios.post.mock.calls[0][1])).toEqual(Utils.removeEmptySpaces(`
+				<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+					<S:Header>
+							<ns2:AuthenticationToken xmlns:ns2="http://auth.ws.fbsaust.com.au" xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
+									<username>${authToken.username}</username>
+									<method>${authToken.method}</method>
+									<password>${authToken.password}</password>
+									<timeout>${authToken.timeout}${authToken.timeoutUnit}</timeout>
+							</ns2:AuthenticationToken>
+					</S:Header>
+					<S:Body>
+							<ns2:Login xmlns:ns2="http://auth.ws.fbsaust.com.au"/>
+					</S:Body>
+			</S:Envelope>
+			`));
+        expect(token).toEqual(mockedToken);
+    });
+});

package/dist/modules/auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./auth.module";
+export * from "./types";

package/dist/modules/auth/index.js

@@ -0,0 +1,2 @@
+export * from "./auth.module";
+export * from "./types";

package/dist/modules/auth/types/index.d.ts

@@ -0,0 +1,7 @@
+export interface AuthenticationToken {
+    username: string;
+    method: string;
+    password: string;
+    timeout: number;
+    timeoutUnit: string;
+}

package/dist/modules/auth/types/index.js

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

package/dist/modules/carrier/carrier.module.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from "axios";
+import { Carrier, CarrierShipment, GetCarrierShipmentByTimeQueryParams } from "./types";
+export declare class CarrierModule {
+    private axiosInstance;
+    private readonly SERVICE_URL;
+    constructor(axiosInstance: AxiosInstance);
+    getCarrier(sessionId: string): Promise<Carrier[]>;
+    getCarrierShipmentByOrderNumber(orderNo: string, sessionId: string): Promise<CarrierShipment[]>;
+    getCarrierShipmentBySysTime(params: GetCarrierShipmentByTimeQueryParams, sessionId: string): Promise<CarrierShipment[]>;
+}