@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyFunctionsProductDiscountsService.ts

@@ -0,0 +1,166 @@
+import { AxiosInstance } from 'axios';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { Logger } from '../Logger';
+import { AbstractService } from './base/AbstractService';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import * as moment from 'moment';
+
+export class ShopifyFunctionsProductDiscountsService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { 
+        super();
+    }
+
+    /**
+     * Creates Product Discount Customization 
+     * 
+     * @param  {string} functionId
+     * @param  {string} metafieldVal
+     * @returns Promise
+     */
+    public create = async (functionId: string, title: string, metafieldVal: string): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                Logger.info(`Creating Product Discount transformation: ${functionId} and metafield val ${metafieldVal}`);
+                const query = gql `mutation {
+                    discountAutomaticAppCreate(automaticAppDiscount: {
+                        title: "${title}",
+                        functionId: "${functionId}"
+                        combinesWith: {
+                            orderDiscounts: true
+                            productDiscounts: true
+                            shippingDiscounts: true
+                        }
+                        startsAt: "${moment().format('YYYY-MM-DDTHH:mm:ss')}"
+                    }) {
+                       automaticAppDiscount {
+                        discountId
+                       }
+                       userErrors {
+                        field
+                        message
+                       }
+                    }
+                }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query), 
+                    variables: { input: functionId }}, { query_cost: 803 });
+
+                if(response && response.data && response.data.data && response.data.data.discountAutomaticAppCreate && response.data.data.discountAutomaticAppCreate.automaticAppDiscount ){
+                    const productDiscountGraphQL = response.data.data.discountAutomaticAppCreate.automaticAppDiscount;
+                    Logger.info(`Product discount created ${JSON.stringify(productDiscountGraphQL)}`);
+                    
+                    const metafieldQuery = gql `mutation MetafieldsSet($customizationId: ID!, $configurationValue: String!) {
+                        metafieldsSet(metafields: [
+                          {
+                            ownerId: $customizationId
+                            namespace: "$app:product-discount"
+                            key: "function-configuration"
+                            value: $configurationValue
+                            type: "json"
+                          }
+                        ]) {
+                          metafields {
+                            id
+                          }
+                          userErrors {
+                            message
+                          }
+                        }
+                      }`;
+                    
+                    const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                        variables: { customizationId: productDiscountGraphQL.discountId, configurationValue: metafieldVal }}, { query_cost: 803 });
+
+                    Logger.info(`Product discount metafield Meta response ${JSON.stringify(metafieldResponse.data)}`);
+                    resolve({ id: this.getIdFromGraphId(productDiscountGraphQL.discountId) });
+                } else {
+                    Logger.error(`Product Discount. Error is ${JSON.stringify(response.data.errors)}. All data is ${JSON.stringify(response.data)}` );
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+  
+    /**
+     * Updates in Product Discount
+     * 
+     * @param  {number} customisationId
+     * @param  {string} metafieldVal
+     * @returns Promise
+     */
+    public update = async (customisationId: number, metafieldVal: string): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                
+                Logger.info(`Product Discount update with ${customisationId}`);
+                const metafieldQuery = gql `mutation MetafieldsSet($customizationId: ID!, $configurationValue: String!) {
+                  metafieldsSet(metafields: [
+                    {
+                      ownerId: $customizationId
+                      namespace: "$app:product-discount"
+                      key: "function-configuration"
+                      value: $configurationValue
+                      type: "json"
+                    }
+                  ]) {
+                    metafields {
+                      id
+                    }
+                    userErrors {
+                      message
+                    }
+                  }
+                }`;
+                    
+                const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                    variables: { customizationId: this.getGraphProductDiscountIdFromId(customisationId), configurationValue: metafieldVal }}, { query_cost: 803 });
+
+                Logger.info(`Meta response ${JSON.stringify(metafieldResponse.data)}`);
+                resolve({ id: customisationId });
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * setMetafield in Product discount
+     * 
+     * @param  {number} customisationId
+     * @param  {string} metafieldVal
+     * @param  {string} key
+     * @returns Promise
+     */
+    public setMetafield = async (customisationId: number, metafieldVal: string, key: string): Promise<{id: number;}> => {
+        return new Promise<{id: number;}>(async (resolve, reject) => {
+            try {
+                
+                Logger.info(`Product Discount meta updated with ${customisationId}`);
+                const metafieldQuery = gql `mutation MetafieldsSet($customizationId: ID!, $configurationValue: String!) {
+                  metafieldsSet(metafields: [
+                    {
+                      ownerId: $customizationId
+                      namespace: "$app:product-discount"
+                      key: "${key}"
+                      value: $configurationValue
+                      type: "json"
+                    }
+                  ]) {
+                    metafields {
+                      id
+                    }
+                    userErrors {
+                      message
+                    }
+                  }
+                }`;
+                    
+                const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                    variables: { customizationId: this.getGraphProductDiscountIdFromId(customisationId), configurationValue: metafieldVal }}, { query_cost: 803 });
+
+                Logger.info(`Set metafield on Product discount response ${JSON.stringify(metafieldResponse.data)}`);
+                resolve({ id: customisationId });
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}

package/shopify/ShopifyInventoryService.ts

@@ -0,0 +1,415 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import { AbstractService } from './base/AbstractService';
+
+export class ShopifyInventoryService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { super(); }
+
+    /**
+     * 
+     * @param  {number} inventoryId
+     * @param  {boolean} trackable. Inventory quantity is traqcked by shopify
+     * @returns Promise
+     */
+    public setItemToBe = async (inventoryId: number, trackable: boolean): Promise<IInventoryItem> => {
+        return new Promise<IInventoryItem>(async (resolve, reject) => {
+            try {
+                Logger.info(`setItemToTrackable ${inventoryId}`);
+                const response = await this.axiosInstance.put(`/inventory_items/${inventoryId}.json`, { inventory_item: { id: inventoryId, tracked: trackable } });
+                resolve(response.data.inventory_item);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Updates Inventory cost per item.
+     * 
+     * @param  {number} inventoryId
+     * @param  {number} cost. New cost per item
+     * @returns Promise true if updated correctly
+     */
+    public setItemCostToBe = async (inventoryId: number, cost: number): Promise<boolean> => {
+        const updatedInventoryItem = await this.setMultipleItemCostToBe([{ inventoryId: inventoryId, cost: cost }]);
+        return updatedInventoryItem?.length === 1 ? true : false;
+    };
+
+    /**
+     * Updates Inventory cost for multiple Inventory items
+     * 
+     * @param  {IIventoryItemCostChangeRequest[]} inventoryCostChanges
+     * @returns Promise inventory item IDs updated
+     */
+    public setMultipleItemCostToBe = async (inventoryCostChanges: IIventoryItemCostChangeRequest[]): Promise<number[]> => {
+        return new Promise<number[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Change Multiple Inventory costs: ${JSON.stringify(inventoryCostChanges)}`);
+
+                const inventoryCostChangeschunks: IIventoryItemCostChangeRequest[][] = this.sliceIntoChunks(inventoryCostChanges, 50);
+
+                if(inventoryCostChangeschunks && inventoryCostChangeschunks.length > 0) {
+                    Logger.info(`Created ${inventoryCostChangeschunks.length} chunks`);
+
+                    for(const inventoryCostChangeschunk of inventoryCostChangeschunks) {
+                        const query = gql`mutation {
+                            ${ inventoryCostChangeschunk.map((iv) => (`
+                                InventoryItem${iv.inventoryId}: inventoryItemUpdate(id: "gid://shopify/InventoryItem/${iv.inventoryId}", input: { cost: ${iv.cost} }) {
+                                    inventoryItem {
+                                        id
+                                    }
+                                    userErrors {
+                                        field
+                                        message
+                                    }
+                                }`)).join('')
+}
+                        }`;
+                        const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: inventoryCostChangeschunk.length * 10 });
+                        if(response && response.data?.data){
+                            Logger.info(`Inventory chunks completed ${JSON.stringify(response.data.data)}`);
+                            const keys = Object.keys(response.data.data);
+                            const itemIDsUpdated: number[] = [];
+                            for(const key of keys) {
+                                const graphQLItemID = response.data.data[key].inventoryItem?.id;
+                                if(graphQLItemID){
+                                    itemIDsUpdated.push(this.getIdFromGraphId(graphQLItemID));
+                                }
+                            }
+                            resolve(itemIDsUpdated);
+                        } else {
+                            Logger.error(`Inventory chunks failed ${JSON.stringify(response ? response.data : '')}`);
+                            resolve([]);
+                        }
+                    }
+                } else {
+                    Logger.error(`No inventory changes sent! ${JSON.stringify(inventoryCostChanges)}`);
+                    resolve([]);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Updates Inventory cost & sku per item.
+     * 
+     * @param  {number} inventoryId
+     * @param  {number} cost. New cost per item
+     * @param  {string} sku. New sku per item
+     * @returns Promise
+     */
+    public setItemCostAndSkuToBe = async (inventoryId: number, cost: number, sku: string): Promise<IInventoryItem> => {
+        return new Promise<IInventoryItem>(async (resolve, reject) => {
+            try {
+                Logger.info(`setItemCostAndSkuToBe ${inventoryId}`);
+                const response = await this.axiosInstance.put(`/inventory_items/${inventoryId}.json`, { inventory_item: { id: inventoryId, cost: cost, sku: sku } });
+                resolve(response.data.inventory_item);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Sets a quantity to the inventory level
+     * 
+     * @param  {number} inventoryId
+     * @param  {number} qty Absolute amount of Qty
+     * @param  {number} locationId
+     * @returns Promise
+     */
+    public setQuantity = async (inventoryId: number, qty: number, locationId: number): Promise<IInventoryLevel> => {
+        return new Promise<IInventoryLevel>(async (resolve, reject) => {
+            try {
+                Logger.info(`setQuantity ${qty} in inventory ID ${inventoryId}`);
+                const response = await this.axiosInstance.post('/inventory_levels/set.json', { location_id: locationId, inventory_item_id: inventoryId, available: qty });
+                resolve(response.data.inventory_level);
+            } catch (error) {Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Adjusts quantity to the inventory level. So it adds or removes the quantity from the actual value
+     * 
+     * @param  {number} inventoryId
+     * @param  {number} qty Absolute amount of Qty
+     * @param  {number} locationId
+     * @returns Promise
+     */
+    public adjustQuantity = async (inventoryId: number, qtyToAdjust: number, locationId: number): Promise<IInventoryLevel> => {
+        return new Promise<IInventoryLevel>(async (resolve, reject) => {
+            try {
+                Logger.info(`adjustsQuantity ${qtyToAdjust} in inventory ID ${inventoryId}`);
+                const response = await this.axiosInstance.post('/inventory_levels/adjust.json', { location_id: locationId, inventory_item_id: inventoryId, available_adjustment: qtyToAdjust });
+                resolve(response.data.inventory_level);
+            } catch (error) {Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Adjusts quantity to the inventory levels of variant. So it adds or removes the quantity from the actual value.
+     * - If quantity is lower than the inventory level. It gets removed from it.
+     * - If quantity is bigger from the inventory level but there are more than one level it tries to remove a bit of stock from each level.
+     * - If quantity is bigger than the invenotry level and there isn't anymore levels then it removes the stock. A negative value will be placed
+     * 
+     * @param  {number} inventoryItemId
+     * @param  {number} qtyToAdjust Absolute amount of Qty
+     * @returns Promise
+     */
+    public adjustQuantityOfInventoryItem = async (inventoryItemId: number, qtyToAdjust: number): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            try {
+                Logger.info(`adjustsQuantity for inventoryItem ${inventoryItemId}`);
+                const inventoryLevels = await this.getLevel(inventoryItemId);
+                Logger.info(`Inventory levels ${JSON.stringify(inventoryLevels)}`);
+                let dynamicQtyToAdjust = parseInt(qtyToAdjust.toString(), 10);
+                for(const level of inventoryLevels) {
+                    if(level.available >= qtyToAdjust) {
+                        this.setQuantity(level.inventory_item_id, level.available - qtyToAdjust, level.location_id);
+                        dynamicQtyToAdjust = 0;
+                        break;
+                    }
+                }
+                if(dynamicQtyToAdjust > 0){
+                    Logger.info('Not enough stock in any of the levels. We will remove it from the first level');
+                    let levelIndex = 0;
+                    const levelNumber = inventoryLevels.length;
+                    for(const level of inventoryLevels) {
+                        Logger.info(`Level ${JSON.stringify(level)}`);
+                        if(level.available >= dynamicQtyToAdjust) {
+                            this.setQuantity(level.inventory_item_id, level.available - dynamicQtyToAdjust, level.location_id);
+                            dynamicQtyToAdjust = 0;
+                            Logger.info(`Removing all from 1st level. Missing Qty ${dynamicQtyToAdjust} & ${level.location_id}`);
+                            break;
+                        } else if (level.available < dynamicQtyToAdjust && levelIndex !== levelNumber - 1) { 
+                            this.setQuantity(level.inventory_item_id, 0, level.location_id);
+                            dynamicQtyToAdjust = dynamicQtyToAdjust - level.available;
+                            Logger.info(`Removing part of it from ${level.inventory_item_id} level. Missing Qty ${dynamicQtyToAdjust} & ${level.location_id}`);
+                        } else if (level.available < dynamicQtyToAdjust && levelIndex === levelNumber - 1) { 
+                            this.setQuantity(level.inventory_item_id, level.available - dynamicQtyToAdjust, level.location_id);
+                            dynamicQtyToAdjust = 0;
+                            Logger.info(`Removing the rest of it from ${level.inventory_item_id} level. Missing Qty ${dynamicQtyToAdjust} & ${level.location_id}`);
+                            break;
+                        } else {
+                            Logger.info('Option of level and stock not detected');
+                        }
+                        levelIndex +=1;
+                    }
+                } else {
+                    Logger.info('All stock removed from one Level');
+                }
+                resolve();
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getLevel = async (inventoryId: number): Promise<IInventoryLevel[]> => {
+        return new Promise<IInventoryLevel[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`getLevel for inventory ID ${inventoryId}`);
+                const response = await this.axiosInstance.get(`/inventory_levels.json?inventory_item_ids=${inventoryId}`);
+                resolve(response.data.inventory_levels);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Returns a list of all iventory Items of the product.
+     * 
+     * @param  {IProduct} product
+     * @returns Promise
+     */
+    public getInventoryItemsOfProduct = async (product: IProduct): Promise<IInventoryItemWithVariantGQL[]> => {
+        return new Promise<IInventoryItemWithVariantGQL[]>(async (resolve, reject) => {
+            try {
+                const productID = product ? product.id : 'empty product (no id)';
+                Logger.info(`Get Inventory Items for product ID ${productID}`);
+                if(!product || !product.variants) {
+                    Logger.info(`No variants for product ID ${productID}`);
+                    resolve([]);
+                } else {
+                    const inventoryItemsWithVariant: IInventoryItemWithVariantGQL[] = [];
+                    const inventoryItemIds = product.variants.map(v => v.inventory_item_id).join(',');
+
+                    const queryIds = product.variants.map(v => this.getInventoryItemIdFromId(v.inventory_item_id));
+                    const query = gql` 
+                        query getInventoryItems($queryIds: [ID!]!) { 
+                            nodes(ids: $queryIds) { 
+                                ... on InventoryItem { 
+                                    id 
+                                    measurement { 
+                                        id 
+                                        weight { 
+                                            unit 
+                                            value 
+                                        }  
+                                    } 
+                                    unitCost { 
+                                        amount 
+                                        currencyCode 
+                                    } 
+                                    requiresShipping 
+                                    tracked
+                                    variant { 
+                                        id 
+                                        price 
+                                    }  
+                                } 
+                            } 
+                        }
+                     `;
+                    
+                    const resp = await this.axiosInstance.post('/graphql.json', { query: print(query), variables: {queryIds: queryIds} });
+                    const inventoryItems: IInventoryItemGQL[] = resp.data.data.nodes;
+                    if(inventoryItemIds && inventoryItems.length > 0){
+                        for(const inventoryItem of inventoryItems) {
+                            const variant = product.variants.find(v => v.inventory_item_id === this.getIdFromGraphId(inventoryItem.id));
+                            const inventoryItemWithVariant: IInventoryItemWithVariantGQL = Object.assign(inventoryItem, { variant_price: parseFloat(variant.price), variant_id: variant.id });
+                            inventoryItemsWithVariant.push(inventoryItemWithVariant);
+                        }
+                    }
+                    Logger.info(`Inventory Items for product ID ${productID} is ${inventoryItemsWithVariant}`);
+                    resolve(inventoryItemsWithVariant);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+    
+    /**
+     * Returns a list of all iventory Levels of the product.
+     * 
+     * @param  {IProduct} product It must have its variants wioth its inventory items IDs.
+     * @returns Promise {IInventoryLevel[]}
+     */
+    public getInventoryLevelsOfProduct = async (product: IProduct): Promise<IInventoryLevel[]> => {
+        try {
+            const productID = product ? product.id : 'empty product (no id)';
+            Logger.info(`get Inventory Levels for product ID ${productID}`);
+            if(!product || !product.variants) {
+                Logger.info(`No variants for product ID ${productID}`);
+                return [];
+            } else {
+                const inventoryItemIds = product.variants.map(v => v.inventory_item_id);
+                const inventoryLevels: IInventoryLevel[] = await this.getInventoryLevelsOfInventoryItems(inventoryItemIds);
+                return inventoryLevels;
+            }
+        } catch (error) { 
+            Logger.error('getInventoryLevelsOfProduct - ', error, ErrorHelper.getErrorFromResponse(error));
+            throw new InspiraShopifyError(error);
+        }
+    };
+
+    /**
+     * Returns a list of all iventory Levels given a list of invenotry item IDs
+     * 
+     * @param  {number[]} inventoryItemsIds
+     * @returns Promise {IInventoryLevel[]}
+     */
+    public getInventoryLevelsOfInventoryItems = async (inventoryItemsIds: number[]): Promise<IInventoryLevel[]> => {
+        try {
+            Logger.info(`get Inventory Levels for inventoryItemsIds ${inventoryItemsIds}`);
+            if(!inventoryItemsIds || inventoryItemsIds.length === 0) {
+                Logger.info(`No inventoryItemsIds ${inventoryItemsIds}`);
+                return [];
+            } else {
+                const inventoryItemIds = inventoryItemsIds.join(',');
+                const response = await this.axiosInstance.get(`/inventory_levels.json?inventory_item_ids=${inventoryItemIds}`);
+                const inventoryLevels: IInventoryLevel[] = response.data.inventory_levels;
+                return inventoryLevels;
+            }
+        } catch (error) {
+            Logger.error('getInventoryLevelsOfInventoryItems - ', error.message, ErrorHelper.getErrorFromResponse(error));
+            throw new InspiraShopifyError(error);
+        }
+    };
+
+    /**
+     * Returns a variant that is the parent of a inventory item
+     * 
+     * @param  {IInventoryItem} inventoryItem
+     * @returns Promise
+     */
+    public getInventoryItemVariant = async(inventoryItem: IInventoryItem): Promise<IVariant> => {
+        return new Promise<IVariant>(async (resolve, reject) => {
+            try {
+                Logger.info(`Get Inventory Variant for InventoryItem ${inventoryItem.id}`);
+                const query = gql` { 
+                    inventoryItem(id: "gid://shopify/InventoryItem/${inventoryItem.id}") {
+                        variant {
+                          id
+                          product {
+                            id
+                          }
+                        }
+                    }
+                }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 3});
+                if(response && response.data && response.data.data && response.data.data.inventoryItem && response.data.data.inventoryItem.variant){
+                    const inventoryItemGraph = response.data.data.inventoryItem;
+                    if(inventoryItemGraph.variant.length == 0) {
+                        resolve(null);
+                    }
+                    Logger.info(`Variant found with id of ${inventoryItemGraph.variant.id}`);
+                    inventoryItemGraph.variant.id = this.getIdFromGraphId(inventoryItemGraph.variant.id);
+                    inventoryItemGraph.variant.product_id = this.getIdFromGraphId(inventoryItemGraph.variant.product.id);
+                    resolve(inventoryItemGraph.variant);
+                } else {
+                    Logger.error(`getInventoryItemVariant not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}` );
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Returns a variant that is the parent of a inventory level
+     * We use the admin_graphql_api_id here as the Inventorylevel webhook kinda sucks and doesn't give us the InventoryLevel id???
+     * 
+     * @param  {IInventoryLevel} inventoryLevel
+     * @returns Promise
+     * TODO: Test (Not used yet)
+     */
+    public getInventoryLevelVariant = async(inventoryLevel: IInventoryLevel): Promise<IVariant> => {
+        return new Promise<IVariant>(async (resolve, reject) => {
+            try {
+                Logger.info(inventoryLevel);
+                Logger.info(`Get Inventory Variant for InventoryLevel ${inventoryLevel.inventory_item_id}`);
+                if(inventoryLevel.inventory_item_id === undefined) {
+                    resolve(null);
+                }
+                const query = gql` { 
+                    inventoryLevel(id: "${inventoryLevel.admin_graphql_api_id}") {
+                        id
+                        item{
+                            variant {
+                            id
+                                product {
+                                    id
+                                }
+                            }
+                        }
+                    }
+                }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 4 });
+                Logger.info(response.data.data);
+                if(response && response.data && response.data.data && response.data.data.inventoryLevel && response.data.data.inventoryLevel.item.variant){
+                    const inventoryItemGraph = response.data.data.inventoryLevel;
+                    if(inventoryItemGraph.item.variant.length == 0) {
+                        resolve(null);
+                    }
+                    Logger.info(`Variant found with id of ${this.getIdFromGraphId(inventoryItemGraph.item.variant.id)}`);
+                    inventoryItemGraph.item.variant.id = this.getIdFromGraphId(inventoryItemGraph.item.variant.id);
+                    inventoryItemGraph.item.variant.product_id = this.getIdFromGraphId(inventoryItemGraph.item.variant.product.id);
+                    resolve(inventoryItemGraph.item.variant);
+                } else {
+                    Logger.error(`getInventoryLevelVariant not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}` );
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+    
+
+
+}

package/shopify/ShopifyLocationService.ts

@@ -0,0 +1,29 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyLocationService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public getAll = async (): Promise<ILocation[]> => {
+        return new Promise<ILocation[]>(async (resolve, reject) => {
+            try {
+                Logger.info('getAll locations');
+                const response = await this.axiosInstance.get('/locations.json');
+                resolve(response.data.locations);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getLocationById = async (id: number): Promise<ILocation> => {
+        return new Promise<ILocation>(async (resolve, reject) => {
+            try {
+                Logger.info(`get location with id of ${id}`);
+                const response = await this.axiosInstance.get(`/locations/${id}.json`);
+                resolve(response.data.location);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}