@dotdev/harmony-sdk 1.0.6

package/README.md

@@ -0,0 +1,88 @@
+# Harmony API SDK
+
+Harmony API SDK is a TypeScript library for interacting with the Harmony API. It provides a simple and type-safe way to use various Harmony services.
+
+## Endpoints
+
+- Authentication
+- Stock lookup
+- [Other main features...]
+
+## Installation (Pending package publication)
+
+As this package is currently developed as part of a monorepo, you need to clone the entire repository and install dependencies locally.
+
+```bash
+git clone [your monorepo repository URL]
+cd [your monorepo directory]
+pnpm install
+```
+
+## Local Build
+
+To build the SDK locally, run the following command:
+
+1. Navigate to the SDK directory
+
+```bash
+cd packages/harmony-sdk
+```
+
+2. Run the build command - This will generate compiled JavaScript files and type declaration files in the `dist` directory.
+
+```bash
+pnpm run build
+```
+
+## Usage
+
+Here's a basic example of how to use the Harmony SDK:
+
+```typescript
+import { HarmonyAPI } from "@dotapparel/harmony-sdk";
+
+const api = new HarmonyAPI("hostname", "port");
+
+async function main() {
+  try {
+    const token = await api.authenticate({
+      username: "your-username",
+      method: "AGENT",
+      password: "your-password",
+    });
+
+    const stockInfo = await api.stockLookup(token, {
+      SearchType: "Barcode",
+      SearchValue: "9338726242178",
+    });
+
+    console.log("Stock info:", stockInfo);
+  } catch (error) {
+    console.error("An error occurred:", error);
+  }
+}
+```
+
+## Development
+
+To contribute to this package:
+
+1. Make your changes in the src directory.
+1. Write tests for your changes in the tests directory.
+1. Run tests:
+
+```bash
+pnpm run test
+```
+
+4. Build the SDK:
+
+```bash
+pnpm run build
+```
+
+5. Commit your changes and open a pull request.
+
+## Publishing
+
+TODO: Add publishing instructions

package/dist/HarmonyAPI.d.ts

@@ -0,0 +1,37 @@
+import { AuthenticationToken, Carrier, CarrierShipment, CreateDiaryQueryParams, Diary, GetCarrierShipmentByTimeQueryParams, GetDiaryQueryParams, ProcessSaleOrderQueryParams, SizeGrid, Stock, StockBarcode, StockCategory, StockClassification, StockClassificationType, StockColor, StockLevel, StockLevelLookupQueryParams, StockLookupRequestParams, Warehouse } from "./modules";
+import { GiftVoucher, GiftVoucherLookupQueryParams, GiftVoucherReservationQueryParams, GiftVoucherUsedQueryParams, GiftVoucherVerificationKeyQueryParams } from "./modules/gift-voucher/types";
+export declare class HarmonyAPI {
+    private baseUrl;
+    private axiosInstance;
+    private authModule;
+    private stockLookupModule;
+    private stockLevelLookupModule;
+    private pointOfSaleModule;
+    private carrierModule;
+    private diaryModule;
+    private giftVoucherModule;
+    constructor(url: string);
+    authenticate(authToken: AuthenticationToken): Promise<string>;
+    stockLookup(params: StockLookupRequestParams, sessionId: string): Promise<Stock[]>;
+    stockCategoryLookup(sessionId: string): Promise<StockCategory[]>;
+    stockBarcodeLookup(params: StockLookupRequestParams, sessionId: string): Promise<StockBarcode[]>;
+    stockColorLookup(sessionId: string): Promise<StockColor[]>;
+    sizeGridLookup(sessionId: string): Promise<SizeGrid[]>;
+    stockClassificationLookup(sessionId: string, searchType?: StockClassificationType): Promise<StockClassification[]>;
+    warehouseLookup(sessionId: string): Promise<Warehouse[]>;
+    stockLevelLookup(params: StockLevelLookupQueryParams, sessionId: string): Promise<StockLevel[]>;
+    stockLevelLookupByWarehouseQuickView(params: StockLevelLookupQueryParams, sessionId: string): Promise<StockLevel[]>;
+    processSalesOrder(params: ProcessSaleOrderQueryParams, sessionId: string): Promise<boolean>;
+    processReturns(params: ProcessSaleOrderQueryParams, sessionId: string): Promise<boolean>;
+    modifyExistingSalesOrder(params: ProcessSaleOrderQueryParams, sessionId: string): Promise<boolean>;
+    cancelExistingSalesOrder(params: ProcessSaleOrderQueryParams, sessionId: string): Promise<boolean>;
+    getCarrier(sessionId: string): Promise<Carrier[]>;
+    getCarrierShipmentByOrderNo(orderNo: string, sessionId: string): Promise<CarrierShipment[]>;
+    getCarrierBySysTime(params: GetCarrierShipmentByTimeQueryParams, sessionId: string): Promise<CarrierShipment[]>;
+    getDiaryBy(params: GetDiaryQueryParams, sessionId: string): Promise<Diary[]>;
+    createDiary(params: CreateDiaryQueryParams, sessionId: string): Promise<boolean>;
+    giftVoucherLookup(params: GiftVoucherLookupQueryParams, sessionId: string): Promise<GiftVoucher[]>;
+    giftVoucherVerificationKey(params: GiftVoucherVerificationKeyQueryParams, sessionId: string): Promise<string>;
+    giftVoucherReservation(params: GiftVoucherReservationQueryParams, sessionId: string): Promise<string>;
+    giftVoucherUsed(params: GiftVoucherUsedQueryParams, sessionId: string): Promise<number>;
+}

package/dist/HarmonyAPI.js

@@ -0,0 +1,113 @@
+import axios from "axios";
+import * as https from "https";
+import { promisify } from "util";
+import { parseString } from "xml2js";
+import { AuthModule, CarrierModule, DiaryModule, GiftVoucherModule, PointOfSaleModule, StockClassificationType, StockLevelLookupModule, StockLookupModule, } from "./modules";
+require("tls").DEFAULT_MIN_VERSION = "TLSv1";
+const parseXml = promisify(parseString);
+export class HarmonyAPI {
+    baseUrl;
+    axiosInstance;
+    authModule;
+    stockLookupModule;
+    stockLevelLookupModule;
+    pointOfSaleModule;
+    carrierModule;
+    diaryModule;
+    giftVoucherModule;
+    constructor(url) {
+        this.baseUrl = url;
+        this.axiosInstance = axios.create({
+            baseURL: this.baseUrl,
+            headers: {
+                "Content-Type": "text/xml;charset=UTF-8",
+            },
+            httpsAgent: new https.Agent({
+                rejectUnauthorized: false,
+            }),
+        });
+        // Initialise modules that correspond to Harmony API services
+        this.authModule = new AuthModule(this.axiosInstance);
+        this.stockLookupModule = new StockLookupModule(this.axiosInstance);
+        this.stockLevelLookupModule = new StockLevelLookupModule(this.axiosInstance);
+        this.pointOfSaleModule = new PointOfSaleModule(this.axiosInstance);
+        this.carrierModule = new CarrierModule(this.axiosInstance);
+        this.diaryModule = new DiaryModule(this.axiosInstance);
+        this.giftVoucherModule = new GiftVoucherModule(this.axiosInstance);
+    }
+    async authenticate(authToken) {
+        return await this.authModule.authenticate(authToken);
+    }
+    // Stock lookup module
+    async stockLookup(params, sessionId) {
+        return await this.stockLookupModule.stockLookup(params, sessionId);
+    }
+    async stockCategoryLookup(sessionId) {
+        return await this.stockLookupModule.stockCategoryLookup(sessionId);
+    }
+    async stockBarcodeLookup(params, sessionId) {
+        return await this.stockLookupModule.stockBarcodeLookup(params, sessionId);
+    }
+    async stockColorLookup(sessionId) {
+        return await this.stockLookupModule.stockColorLookup(sessionId);
+    }
+    async sizeGridLookup(sessionId) {
+        return await this.stockLookupModule.sizeGridLookup(sessionId);
+    }
+    async stockClassificationLookup(sessionId, searchType = StockClassificationType.STK1) {
+        return await this.stockLookupModule.stockClassificationLookup(sessionId, searchType);
+    }
+    // Stock level lookup module
+    async warehouseLookup(sessionId) {
+        return await this.stockLevelLookupModule.warehouseLookup(sessionId);
+    }
+    async stockLevelLookup(params, sessionId) {
+        return await this.stockLevelLookupModule.stockLevelLookup(params, sessionId);
+    }
+    async stockLevelLookupByWarehouseQuickView(params, sessionId) {
+        return await this.stockLevelLookupModule.stockLevelLookupByWarehouseQuickView(params, sessionId);
+    }
+    // Point of sale module
+    async processSalesOrder(params, sessionId) {
+        return await this.pointOfSaleModule.processSalesOrder(params, sessionId);
+    }
+    async processReturns(params, sessionId) {
+        return await this.pointOfSaleModule.processReturns(params, sessionId);
+    }
+    async modifyExistingSalesOrder(params, sessionId) {
+        return await this.pointOfSaleModule.modifyExistingSalesOrder(params, sessionId);
+    }
+    async cancelExistingSalesOrder(params, sessionId) {
+        return await this.pointOfSaleModule.cancelExistingSalesOrder(params, sessionId);
+    }
+    // Carrier module
+    async getCarrier(sessionId) {
+        return await this.carrierModule.getCarrier(sessionId);
+    }
+    async getCarrierShipmentByOrderNo(orderNo, sessionId) {
+        return await this.carrierModule.getCarrierShipmentByOrderNumber(orderNo, sessionId);
+    }
+    async getCarrierBySysTime(params, sessionId) {
+        return await this.carrierModule.getCarrierShipmentBySysTime(params, sessionId);
+    }
+    // Diary module
+    async getDiaryBy(params, sessionId) {
+        return await this.diaryModule.getDiaryBy(params, sessionId);
+    }
+    async createDiary(params, sessionId) {
+        return await this.diaryModule.createDiary(params, sessionId);
+    }
+    // Gift voucher module
+    async giftVoucherLookup(params, sessionId) {
+        return this.giftVoucherModule.giftVoucherLookup(params, sessionId);
+    }
+    async giftVoucherVerificationKey(params, sessionId) {
+        return this.giftVoucherModule.giftVoucherVerificationKey(params, sessionId);
+    }
+    async giftVoucherReservation(params, sessionId) {
+        return this.giftVoucherModule.giftVoucherVerificationKey(params, sessionId);
+    }
+    async giftVoucherUsed(params, sessionId) {
+        return this.giftVoucherModule.giftVoucherUsed(params, sessionId);
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,15 @@
+export declare class HarmonyAPIError extends Error {
+    constructor(message: string);
+}
+export declare class AuthenticationError extends HarmonyAPIError {
+    constructor(message: string);
+}
+export declare class RequestError extends HarmonyAPIError {
+    constructor(message: string);
+}
+export interface ApiError {
+    status?: string;
+    code?: string;
+    name?: string;
+    message?: string;
+}

package/dist/errors/index.js

@@ -0,0 +1,18 @@
+export class HarmonyAPIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HarmonyAPIError";
+    }
+}
+export class AuthenticationError extends HarmonyAPIError {
+    constructor(message) {
+        super(message);
+        this.name = "AuthenticationError";
+    }
+}
+export class RequestError extends HarmonyAPIError {
+    constructor(message) {
+        super(message);
+        this.name = "RequestError";
+    }
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,50 @@
+import { AxiosInstance } from "axios";
+import { ApiError, RequestError } from "../errors";
+import { ParamLimits, ServiceAlias } from "../modules";
+export * from "./utils";
+export declare abstract class ApiHelper {
+    static sendSoapRequest(endpoint: string, axiosInstance: AxiosInstance, requestBody?: string, type?: "GET" | "POST"): Promise<any>;
+    /**
+     * Helper function to create SOAP request body for Harmony API
+     *
+     * @static
+     * @param {(string | string[])} methodName
+     * @param {string} sessionId
+     * @param {ServiceAlias} serviceAlias
+     * @param {?string} [body]
+     * @returns {string}
+     */
+    static createServiceRequestBody(methodName: string | string[], sessionId: string, serviceAlias: ServiceAlias, body?: string): string;
+    /**
+     * Private method to send SOAP request to different endpoint in Point Of Sale service in Harmony API
+     *
+     * @private
+     * @async
+     * @template R
+     * @param {string} methodName
+     * @param {string} sessionId
+     * @returns {Promise<R>}
+     */
+    static sendServiceRequest<R>(serviceName: string, methodName: string | string[], sessionId: string, serviceAlias: ServiceAlias, axios: AxiosInstance, body?: string): Promise<R>;
+    static parseError(error: any): Promise<RequestError>;
+    /**
+     * Extract error response from Harmony in XML format and convert it to JSON format for ease of debugging
+     *
+     * @static
+     * @async
+     * @param {*} error XML error string
+     * @returns {Promise<ApiError>} JSON error object
+     */
+    static parseHarmonyErrorResponse(error: any): Promise<ApiError>;
+}
+/**
+ * Check whether the provided parameters meet the specified limits. If any parameter exceeds the limit, an error will be thrown.
+ * If all checks passed, return true.
+ *
+ * @export
+ * @template T
+ * @param {T} params set of parameters to be checked
+ * @param {ParamLimits<T>} limits limit object with same properties as the parameter object, with value of each key being a number or a function that returns a boolean
+ * @returns {boolean} returns true if all checks passed
+ */
+export declare function checkParamLimits<T>(params: T, limits: ParamLimits<T>): boolean;

package/dist/helpers/index.js

@@ -0,0 +1,167 @@
+import axios from "axios";
+import { promisify } from "util";
+import { parseString } from "xml2js";
+import { RequestError } from "../errors";
+import { Utils } from "./utils";
+export * from "./utils";
+const parseXml = promisify(parseString);
+export class ApiHelper {
+    static async sendSoapRequest(endpoint, axiosInstance, requestBody, type = "POST") {
+        const url = `${endpoint}?wsdl`;
+        try {
+            let response;
+            switch (type) {
+                case "GET":
+                    response = await axiosInstance.get(url, {
+                        params: {},
+                    });
+                    break;
+                case "POST":
+                default:
+                    response = await axiosInstance.post(url, requestBody, {
+                    // headers: {
+                    //   'SOAPAction': request.action
+                    // }
+                    });
+                    break;
+            }
+            const result = (await parseXml(response?.data)); // fix type
+            return result["S:Envelope"]["S:Body"][0];
+        }
+        catch (error) {
+            throw await ApiHelper.parseError(error);
+        }
+    }
+    /**
+     * Helper function to create SOAP request body for Harmony API
+     *
+     * @static
+     * @param {(string | string[])} methodName
+     * @param {string} sessionId
+     * @param {ServiceAlias} serviceAlias
+     * @param {?string} [body]
+     * @returns {string}
+     */
+    static createServiceRequestBody(methodName, sessionId, serviceAlias, body) {
+        const soapNamespace = "S";
+        // Extract method name and construct corresponding properties for the body of the SOAP request and the response from the API
+        const bodyMethodName = Array.isArray(methodName)
+            ? methodName.join("")
+            : methodName;
+        const soapBody = `<${serviceAlias}:${bodyMethodName}>${body ?? ""}</${serviceAlias}:${bodyMethodName}>`;
+        const soapHeader = `
+				<${serviceAlias}:SessionId>${sessionId}</${serviceAlias}:SessionId>
+			`;
+        return `
+				<${soapNamespace}:Envelope xmlns:${soapNamespace}="http://schemas.xmlsoap.org/soap/envelope/" xmlns:${serviceAlias}="http://${serviceAlias}.ws.fbsaust.com.au">
+					<${soapNamespace}:Header>
+						${soapHeader}
+					</${soapNamespace}:Header>
+					<${soapNamespace}:Body>
+						${soapBody}
+					</${soapNamespace}:Body>
+				</${soapNamespace}:Envelope>
+			`;
+    }
+    /**
+     * Private method to send SOAP request to different endpoint in Point Of Sale service in Harmony API
+     *
+     * @private
+     * @async
+     * @template R
+     * @param {string} methodName
+     * @param {string} sessionId
+     * @returns {Promise<R>}
+     */
+    static async sendServiceRequest(serviceName, methodName, sessionId, serviceAlias, axios, body) {
+        // Extract method name and construct corresponding properties for the body of the SOAP request and the response from the API
+        const responseMethodName = Array.isArray(methodName)
+            ? `ns2:${methodName[0]}Response`
+            : `ns2:${methodName}Response`;
+        const requestBody = ApiHelper.createServiceRequestBody(methodName, sessionId, serviceAlias, body);
+        const response = await ApiHelper.sendSoapRequest(serviceName, axios, requestBody);
+        return response[responseMethodName][0];
+    }
+    static async parseError(error) {
+        if (axios.isAxiosError(error)) {
+            if (error?.response) {
+                const parsedError = await ApiHelper.parseHarmonyErrorResponse(error?.response?.data);
+                return new RequestError(`API request failed with status ${error.response.status}: {code: ${parsedError?.code}, name: ${parsedError?.name}, message: ${parsedError?.message}}`);
+            }
+            else if (error?.request) {
+                return new RequestError("No response received from the server during API call");
+            }
+            else {
+                return new RequestError(`API request setup failed: ${error?.message}`);
+            }
+        }
+        else {
+            return new RequestError(`An unexpected error occurred during API request: ${JSON.stringify(error.message)}`);
+        }
+    }
+    /**
+     * Extract error response from Harmony in XML format and convert it to JSON format for ease of debugging
+     *
+     * @static
+     * @async
+     * @param {*} error XML error string
+     * @returns {Promise<ApiError>} JSON error object
+     */
+    static async parseHarmonyErrorResponse(error) {
+        if (error == null)
+            return { code: "", name: "", message: "" };
+        const result = (await parseXml(error));
+        const errorDetails = result["S:Envelope"]["S:Body"][0]["S:Fault"][0];
+        // Extract error response body
+        const code = Utils.nonEmptyArray(errorDetails["faultcode"])
+            ? errorDetails["faultcode"][0]
+            : "";
+        const name = Utils.nonEmptyArray(errorDetails["faultstring"])
+            ? errorDetails["faultstring"][0]
+            : "";
+        // extract error message
+        const detail = errorDetails["detail"];
+        const fault = Utils.nonEmptyArray(detail)
+            ? detail[0]["ns2:ServiceFault"]
+            : [];
+        const message = Utils.nonEmptyArray(fault) ? fault[0]["errorDetails"] : [];
+        return {
+            code,
+            name,
+            message: message[0] ?? "",
+        };
+    }
+}
+/**
+ * Check whether the provided parameters meet the specified limits. If any parameter exceeds the limit, an error will be thrown.
+ * If all checks passed, return true.
+ *
+ * @export
+ * @template T
+ * @param {T} params set of parameters to be checked
+ * @param {ParamLimits<T>} limits limit object with same properties as the parameter object, with value of each key being a number or a function that returns a boolean
+ * @returns {boolean} returns true if all checks passed
+ */
+export function checkParamLimits(params, limits) {
+    for (const key in params) {
+        const val = params[key];
+        const limit = limits[key];
+        // Only perform checks if both param value and limit are defined
+        if (val && limit) {
+            // If limit type is a number a.k.a length limit, check if provided string value exceeds the length limit
+            if (typeof limit === "number") {
+                const valStr = typeof val === "string" ? val : val.toString();
+                if (valStr.length > limit) {
+                    throw new Error(`Provided value for "${key}" exceeds limit of ${limit}`);
+                }
+                // Otherwise call limit function to determine whether value meets the condition
+            }
+            else {
+                if (!limit(val)) {
+                    throw new Error(`Invalid value for parameter "${key}": ${val}`);
+                }
+            }
+        }
+    }
+    return true;
+}

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

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

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("") ?? "",
+    });
+}