@sommpicks/sommpicks-shopify 24.12.0

package/shopify/product/ShopifyVariantService.ts

@@ -0,0 +1,584 @@
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { AxiosInstance } from 'axios';
+import { AbstractService } from '../base/AbstractService';
+import { Logger } from '../../Logger';
+import InspiraShopifyError from '../errors/InspiraShopifyError';
+import { ShopifyProductServiceHelper } from '../helpers/ShopifyProductServiceHelper';
+
+export type ConfirmationUpdate <
+    T extends string, 
+    U extends string,
+>  = 
+    | {
+        [K in T]: true;
+    } & {
+        [K in U]: boolean;
+    }
+    | {
+        [K in T]: false;
+    } & {
+        [K in U]?: boolean;
+    }
+export class ShopifyVariantService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance, private shopifyProductServiceHelper: ShopifyProductServiceHelper) {
+        super();
+    }
+
+    /**
+     * 
+     * @param {number} productId where to create the variant.
+     * @param {IVariant} variant to be created
+     * @param {string} imageSrc to add to the variant.
+     * @param {string[]} productOptionNames option names. If variant has option values this is required.
+     * @param locationId where to add stock to.
+     * @returns {IVariant} variant created or null if error.
+     */
+    public create = async (productId: number, variant: IVariant, imageSrc: string, productOptionNames: string[], locationId: number, retrieveInventory: boolean, removeStandaloneVariant: boolean): Promise<IVariant> => {
+        try {
+            Logger.info(`ShopifyVariantService - create -> variant for product ${productId} --- variant ${JSON.stringify(variant)}`);
+            const variantToCreate: ShopifygraphQl.IVariantToPost = this.shopifyProductServiceHelper.getVariantToPost(variant, { imageSrc: imageSrc }, productOptionNames, locationId);
+            const variantsCreateQuery = ShopifyProductServiceHelper.graphQLQuery.getVariantsBulkCreateMutation(imageSrc ? true : false, retrieveInventory, removeStandaloneVariant);
+            Logger.info(`ShopifyVariantService - create -> Product Variant to create  .... ${JSON.stringify(variantToCreate)}`);
+            Logger.info(`ShopifyVariantService - create -> Product Variant to create query .... ${JSON.stringify(variantsCreateQuery)}`);
+            const variables: { productId: string; variants: ShopifygraphQl.IVariantToPost[], media?: { mediaContentType: 'IMAGE', originalSource: string; }[]; } = { productId: this.getGraphProductIdFromId(productId), variants: [variantToCreate] };
+            if (imageSrc) {
+                variables.media = [{ originalSource: imageSrc.trim().replace(/ /g, '%20'), mediaContentType: 'IMAGE' }];
+            }
+            const variantsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${variantsCreateQuery}`), variables: variables }, { query_cost: 50 });
+            let createdVariant = null;
+            if (variantsResponse && variantsResponse.data && variantsResponse.data.data && variantsResponse.data.data.productVariantsBulkCreate && variantsResponse.data.data.productVariantsBulkCreate.productVariants) {
+                for (const graphVariant of variantsResponse.data.data.productVariantsBulkCreate.productVariants) {
+                    createdVariant = this.shopifyProductServiceHelper.getVariant(graphVariant);
+                }
+            } else {
+                Logger.error(`ShopifyVariantService - create -> Product variant was not created. ${productId}`);
+            }
+            return createdVariant;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * To update inventory prodvide locationID.
+     * To update option value provide option Names.
+     * When imageSrc is set to null it is not updated.
+     * 
+     * @param {IVariant} variant 
+     * @param {number} locationID 
+     * @param {string[]} productOptionNames 
+     * @param {number} variantId
+     * @param {number} productId
+     * @param {imageSrc?: string; imageId?: number;} img
+     * 
+     * @returns 
+     */
+    public update = async (variant: IVariant, productOptionNames: string[], locationID: number, variantId: number, productId: number, img: { imageSrc?: string; imageId?: number; }, retrieveInventory: boolean, taxableSetting: ConfirmationUpdate<'updateTaxable', 'taxable'>, trackInventorySetting: ConfirmationUpdate<'updateTrackInventory', 'trackInventory'>): Promise<IVariant> => {
+        try {
+            Logger.info(`ShopifyVariantService - update variant with id ${variantId} - variant: ${JSON.stringify(variant)}`);
+            if(trackInventorySetting.updateTrackInventory) {
+                variant.inventory_management = trackInventorySetting.trackInventory ? 'SOMEONE' : 'NOT_MANGED';
+            }
+            const variantToUpdate: ShopifygraphQl.IVariantToPost = this.shopifyProductServiceHelper.getVariantToUpdate(variant, { imageSrc: img?.imageSrc, imageId: img?.imageId }, productOptionNames, taxableSetting);
+            variantToUpdate.id = this.getGraphProductVariantIdFromId(variantId);
+            const variantsCreateQuery = retrieveInventory ? ShopifyProductServiceHelper.graphQLQuery.productVariantsBulkUpdate : ShopifyProductServiceHelper.graphQLQuery.productVariantsBulkUpdateWithoutInventory;
+            Logger.info(`ShopifyVariantService - update -> Product Variant to update  .... ${JSON.stringify(variantToUpdate)}`);
+            Logger.info(`ShopifyVariantService - update -> Product Variant to update query .... ${JSON.stringify(variantsCreateQuery)}`);
+            const variantsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${variantsCreateQuery}`), variables: { productId: this.getGraphProductIdFromId(productId), variants: [variantToUpdate] } }, { query_cost: 50 });
+            let updatedVariant: IVariant = null;
+            if (variantsResponse && variantsResponse.data && variantsResponse.data.data && variantsResponse.data.data.productVariantsBulkUpdate && variantsResponse.data.data.productVariantsBulkUpdate.productVariants) {
+                const variants: ShopifygraphQl.IGenericVariantResponse[] = variantsResponse.data.data.productVariantsBulkUpdate.productVariants;
+                for (const graphVariant of variants) {
+                    if (variantId === this.getIdFromGraphId(graphVariant.id)) {
+                        updatedVariant = this.shopifyProductServiceHelper.getVariant(graphVariant);
+                        if (locationID && variant.inventory_quantity) {
+                            Logger.info(`ShopifyVariantService - update -> Inventory adjust for product ${productId} and variant ${variantId}`);
+                            await this.setInventory(locationID, updatedVariant.inventory_item_id, variant.inventory_quantity);
+                            updatedVariant.inventory_quantity = variant.inventory_quantity;
+                        }
+                        break;
+                    }
+                }
+            } else {
+                Logger.error(`ShopifyVariantService - update -> Product variant was not updated. ${productId} - ${JSON.stringify(variantsResponse.data.data)}`);
+            }
+            return updatedVariant;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * To update option value provide option Names.
+     * To update images, provide image data mapped to variant ID
+     * Provide Location to update inventory. Location ID must be mapped to variant ID
+     * 
+     * @param {number} productId
+     * @param {IVariant[]} variants
+     * @param {{ productOptionNames: string[], imgs?: { variantId: number, img?: { imageSrc?: string; imageId?: number }}[] }} updateProperty
+     * @param {boolean} retrieveInventory
+     * 
+     * @returns 
+     */
+    public bulkUpdate = async (productId: number, variants: IVariant[], updateProperty: {
+        productOptionNames: string[],
+        locationIDs: { variantId: number, locationID: number }[],
+        imgs?: { variantId: number, img?: { imageSrc?: string; imageId?: number } }[]
+    }, retrieveInventory: boolean): Promise<IVariant[]> => {
+        try {
+            if (!variants.every(el => el.id)) throw new Error('Some variants does not have ID associated with them');
+
+            Logger.info(`ShopifyVariantService - updating variants - ${JSON.stringify(variants)} - for product ID ${productId}`);
+
+            const variantsToUpdate: ShopifygraphQl.IVariantToPost[] = [];
+            variants.forEach(v => {
+                const i_mg = updateProperty.imgs?.find(i => i.variantId === v.id).img;
+                const v_prep = this.shopifyProductServiceHelper.getVariantToUpdate(
+                    v,
+                    { imageSrc: i_mg?.imageSrc, imageId: i_mg?.imageId },
+                    updateProperty.productOptionNames,
+                    { updateTaxable: true, taxable: v.taxable  }
+                );
+                v_prep.id = this.getGraphProductVariantIdFromId(v.id);
+                variantsToUpdate.push(v_prep);
+            });
+
+            const variantBulkUpdateQuery = retrieveInventory ? ShopifyProductServiceHelper.graphQLQuery.productVariantsBulkUpdate : ShopifyProductServiceHelper.graphQLQuery.productVariantsBulkUpdateWithoutInventory;
+            Logger.info(`ShopifyVariantService - updating variants - Prepared Variants : ${JSON.stringify(variantsToUpdate)}`);
+            Logger.info(`ShopifyVariantService - updating variants - Bulk update variants query : ${JSON.stringify(variantBulkUpdateQuery)}`);
+            const variantsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${variantBulkUpdateQuery}`), variables: { productId: this.getGraphProductIdFromId(productId), variants: variantsToUpdate } });
+
+            const updatedVariants: IVariant[] = [];
+            if (variantsResponse && variantsResponse.data && variantsResponse.data.data && variantsResponse.data.data.productVariantsBulkUpdate && variantsResponse.data.data.productVariantsBulkUpdate.productVariants) {
+                const responseVariants: ShopifygraphQl.IGenericVariantResponse[] = variantsResponse.data.data.productVariantsBulkUpdate.productVariants;
+                for (const graphVariant of responseVariants) {
+                    const updatedVariant = this.shopifyProductServiceHelper.getVariant(graphVariant);
+                    const originalVariant = variants.find(v => v.id === this.getIdFromGraphId(graphVariant.id));
+
+                    if (originalVariant) {
+                        const location = updateProperty.locationIDs.find(l => l.variantId === updatedVariant.id);
+
+                        if (location.locationID) {
+                            Logger.info(`ShopifyVariantService - update -> Inventory adjust for product ${productId} and variant ${updatedVariant.id}`);
+                            await this.setInventory(location.locationID, updatedVariant.inventory_item_id, updatedVariant.inventory_quantity);
+                        } else {
+                            Logger.error(`ShopifyVariantService - update -> Location ID not found for variant ${updatedVariant.id}`);
+                            Logger.error(`ShopifyVariantService - update -> Failed to update inventory for variant ${updatedVariant.id}`);
+                        }
+                        updatedVariants.push(updatedVariant);
+                        break;
+                    }
+                }
+            } else {
+                Logger.error(`ShopifyVariantService - update -> Product variant was not updated. ${productId} - ${JSON.stringify(variantsResponse.data.data)}`);
+            }
+
+            return updatedVariants;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * @param {number} locationID 
+     * @param {number} inventoryItemId 
+     * @param {number} delta 
+     * @returns 
+     */
+    public adjustInventory = async (locationID: number, inventoryItemId: number, delta: number): Promise<boolean> => {
+        try {
+            Logger.info(`ShopifyVariantService - adjustInventory - ${delta} in location ${locationID} and inventory item: ${inventoryItemId}`);
+
+            const inventoryToUpdate: ShopifygraphQl.IVariantInventoryToPut = { reason: 'correction', name: 'available', changes: [{ delta: delta, inventoryItemId: this.getGraphInventoryItemIdFromId(inventoryItemId), locationId: this.getGraphLocationIdFromId(locationID) }] };
+
+            const variantsUpdateInventory = ShopifyProductServiceHelper.graphQLQuery.variantUpdateInventory;
+            Logger.info(`ShopifyVariantService - adjustInventory -> update  .... ${JSON.stringify(inventoryToUpdate)}`);
+            Logger.info(`ShopifyVariantService - adjustInventory -> query .... ${JSON.stringify(variantsUpdateInventory)}`);
+            const variantsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${variantsUpdateInventory}`), variables: { input: inventoryToUpdate } }, { query_cost: 50 });
+
+            if (variantsResponse && variantsResponse.data && variantsResponse.data.data && variantsResponse.data.data.inventoryAdjustQuantities?.inventoryAdjustmentGroup?.createdAt) {
+                Logger.info(`ShopifyVariantService - adjustInventory -> ${JSON.stringify(variantsResponse.data.data.inventoryAdjustQuantities?.inventoryAdjustmentGroup)}`);
+                return true;
+            } else {
+                Logger.error(`We could not adjust inventory Product variant on inventoryItemId ${inventoryItemId} - ${JSON.stringify(variantsResponse.data.data.inventoryAdjustQuantities?.userErrors)}`);
+                return false;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * @param {number} locationID 
+     * @param {number} inventoryItemId 
+     * @param {number} delta 
+     * @returns 
+     */
+    public setInventory = async (locationID: number, inventoryItemId: number, quantity: number): Promise<boolean> => {
+        try {
+            Logger.info(`ShopifyVariantService - setInventory - ${quantity} in location ${locationID} and inventory item: ${inventoryItemId}`);
+
+            const inventoryToUpdate: ShopifygraphQl.IVariantInventoryToPut = { ignoreCompareQuantity: true, reason: 'correction', name: 'available', quantities: [{ quantity: quantity, inventoryItemId: this.getGraphInventoryItemIdFromId(inventoryItemId), locationId: this.getGraphLocationIdFromId(locationID) }] };
+
+            const variantsUpdateInventory = ShopifyProductServiceHelper.graphQLQuery.variantSetInventory;
+            Logger.info(`ShopifyVariantService - setInventory -> update  .... ${JSON.stringify(inventoryToUpdate)}`);
+            Logger.info(`ShopifyVariantService - setInventory -> query .... ${JSON.stringify(variantsUpdateInventory)}`);
+            const variantsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${variantsUpdateInventory}`), variables: { input: inventoryToUpdate } }, { query_cost: 50 });
+
+            if (variantsResponse && variantsResponse.data && variantsResponse.data.data && variantsResponse.data.data.inventorySetQuantities?.inventoryAdjustmentGroup?.changes) {
+                Logger.info(`ShopifyVariantService - setInventory -> ${JSON.stringify(variantsResponse.data.data.inventorySetQuantities?.inventoryAdjustmentGroup)}`);
+                return true;
+            } else {
+                Logger.error(`We could not set inventory Product variant on inventoryItemId ${inventoryItemId} - ${JSON.stringify(variantsResponse.data.data.inventorySetQuantities?.userErrors)}`);
+                return false;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    public getCount = async (productId: number): Promise<number> => {
+
+        try {
+            Logger.info(`Counting all variants for product ${productId}`);
+            const countVariantsQuery = `{ product(id: "${this.getGraphProductIdFromId(productId)}")  {
+                        id
+                        variants(first: 250) {
+                            edges {
+                                node {
+                                    id
+                                }
+                            }
+                        }
+                    }
+                }`;
+            const variantsCountResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${countVariantsQuery}`) }, { query_cost: 50 });
+            if (variantsCountResponse && variantsCountResponse.data && variantsCountResponse.data.data && variantsCountResponse.data.data.product?.variants) {
+                return variantsCountResponse.data.data.product?.variants?.edges?.length ? variantsCountResponse.data.data.product.variants.edges.length : 0;
+            } else {
+                Logger.error(`ShopifyVariantService - getCount -> We could not find variants for ${productId}`);
+            }
+
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * @param {number} variantId
+     * @returns {IVariant} variant
+     */
+    public getById = async (variantId: number): Promise<IVariant> => {
+        try {
+            Logger.info(`ShopifyVariantService - getById -> Get variant with id ${variantId}`);
+            const getVariantQuery = ShopifyProductServiceHelper.graphQLQuery.getProductVariant;
+            Logger.info(`ShopifyVariantService - getById -> Product graphQL query going in ${getVariantQuery}`);
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${getVariantQuery}`), variables: { variantId: this.getGraphProductVariantIdFromId(variantId) } }, { query_cost: 10 });
+            if (response && response.data && response.data.data && response.data.data.productVariant) {
+                const responseVariant: ShopifygraphQl.IGenericVariantResponse = response.data.data.productVariant;
+                const variant = this.shopifyProductServiceHelper.getVariant(responseVariant);
+                return variant;
+            } else {
+                Logger.error(`ShopifyVariantService - getById -> ${variantId} not found`);
+                return null;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    public delete = async (productId: number, variantsIds: number[]): Promise<void> => {
+        try {
+            Logger.info(`ShopifyVariantService - delete -> Delete variant id ->  ${variantsIds}`);
+            const deleteVariantsMutation = ShopifyProductServiceHelper.graphQLQuery.deleteVariantsMutation;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${deleteVariantsMutation}`), variables: { productId: this.getGraphProductIdFromId(productId), variantsIds: variantsIds.map(vId => this.getGraphProductVariantIdFromId(vId)) } }, { query_cost: 20 });
+            if (response && response.data && response.data.data && response.data.data.productVariantsBulkDelete?.product?.id) {
+                Logger.info(`ShopifyVariantService - delete -> Deleted ${variantsIds.length} variants from product ${productId}`);
+            } else {
+                throw new InspiraShopifyError({ message: `${JSON.stringify(response.data.data.productVariantsBulkDelete?.userErrors)}` });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Gets All metafields of a product variant
+     * 
+     * @param  {number} variantId
+     * @returns Promise
+     */
+    public getMetafields = async (variantId: number): Promise<IMetafield[]> => {
+        try {
+            Logger.info(`ShopifyVariantService - getMetafields -> Getting metafields for variant id ->  ${variantId}`);
+            const getMetafieldsQuery = ShopifyProductServiceHelper.graphQLQuery.getProductVariantMetafields;
+            const query = gql`${getMetafieldsQuery}`;
+            Logger.info(`ShopifyVariantService - getMetafields -> rawQuery ${getMetafieldsQuery}`);
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query), variables: { variantId: this.getGraphProductVariantIdFromId(variantId) } }, { query_cost: 20 });
+
+            if (response.data.data.productVariant?.metafields?.nodes && response.data.data.productVariant.metafields.nodes.length > 0) {
+                const metafieldsNodes: IMetafieldGraphQL[] = response.data.data.productVariant.metafields.nodes;
+                const metafields: IMetafield[] = metafieldsNodes.map(m => ({ id: this.getIdFromGraphId(m.id), description: m.description, key: m.key, value: m.value, namespace: m.namespace, type: m.type }));
+                return metafields;
+            } else {
+                if (response.data.data.productVariant.metafields?.nodes?.length === 0 && !response.data.errors) {
+                    Logger.info(`ShopifyVariantService - getMetafields -> we haven't found any metafield. Data ${JSON.stringify(response.data.data)}`);
+                } else {
+                    Logger.error(`ShopifyVariantService - getMetafields -> not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}`);
+                }
+                return [];
+            }
+
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * Adds or updates a metafield.
+     * Metafield type, key, namespace and value must be set
+     * 
+     * @param  {number} id - variant ID
+     * @param  {IMetafield[]} metafields to be saved
+     * @returns Promise
+     */
+    public saveOrUpdateMetafields = async (id: number, metafields: IMetafield[]): Promise<IMetafield[]> => {
+        try {
+            Logger.info(`ShopifyVariantService - saveOrUpdateMetafields -> for variant id ->  ${id}`);
+
+            const metafieldsChunks = this.sliceIntoChunks(metafields, 20);
+
+            if (metafields?.length) {
+                for (const [index, metafiledsChunk] of metafieldsChunks.entries()) {
+                    Logger.info(`ShopifyVariantService - saveOrUpdateMetafields -> processing chunck ${index}`);
+                    const metafieldsToPost: IMetafieldCreate_GraphQL[] = metafiledsChunk.map(m => ({ ownerId: this.getGraphProductVariantIdFromId(id), value: m.value, key: m.key, type: m.type, namespace: m.namespace }));
+                    const rawQuery = `mutation MetafieldsSet($metafields: [MetafieldsSetInput!]!) {
+                            metafieldsSet(metafields: $metafields) {
+                                metafields {
+                                    id
+                                    key
+                                    namespace
+                                    value
+                                    type
+                                }
+                                userErrors {
+                                    field
+                                    message
+                                    code
+                                }
+                            }
+                        }`;
+                    Logger.info(`ShopifyVariantService - saveOrUpdateMetafields -> ${rawQuery}`);
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`), variables: { metafields: metafieldsToPost } }, { query_cost: 10 * metafiledsChunk.length });
+                    Logger.info(`ShopifyVariantService - saveOrUpdateMetafields -> ${JSON.stringify(response.data)}`);
+                    if (response.data?.data?.metafieldsSet?.metafields?.length > 0) {
+                        return response.data?.data?.metafieldsSet?.metafields.map((p: IMetafieldGraphQL) => ({ id: this.getIdFromGraphId(p.id), key: p.key, value: p.value, namespace: p.namespace, type: p.type }));
+                    } else {
+                        if (response?.data?.data?.metafieldsSet?.userErrors) {
+                            Logger.error(`ShopifyVariantService - saveOrUpdateMetafields ->  ${JSON.stringify(response?.data?.data?.metafieldsSet?.userErrors)}`);
+                            throw new InspiraShopifyError({ message: JSON.stringify(response.data?.data?.metafieldsSet?.userErrors) });
+                        } else {
+                            return [];
+                        }
+                    }
+                }
+            } else {
+                Logger.info(`ShopifyVariantService - saveOrUpdateMetafields -> for product id ->  ${id} - no metafields provided`);
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+
+    /**
+     * Deletes a metafields by ID for a product.
+     * 
+     * @param  {number} metafieldIds (max of 50 metafileds)
+     * @returns Promise return num of deleted metafiedls
+     */
+    public deleteMetafieldsByIds = async (metafieldIds: number[]): Promise<number> => {
+        try {
+            Logger.info(`ShopifyVariantService - deleteMetafieldsByIds -> Deleting metafield ids ->  ${metafieldIds}`);
+            const query = gql`mutation {
+                    ${metafieldIds.map((id) => (`
+                        metafield${id}: metafieldDelete(input: { id: "${this.getGraphMetafieldIdFromId(id)}" }) {
+                            deletedId
+                            userErrors {
+                                field
+                                message
+                            }
+                        }`)).join('')}
+                }`;
+            const metafieldsDeleteResponse = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 10 * metafieldIds.length });
+            if (metafieldsDeleteResponse.data?.data) {
+                let numDeleted = 0;
+                for (const metaId of metafieldIds) {
+                    if (metafieldsDeleteResponse.data?.data[`metafield${metaId}`].deletedId) {
+                        numDeleted += 1;
+                    }
+                }
+                return numDeleted;
+            } else {
+                return 0;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Deletes a metafield by Key for a variant.
+     * 
+     * @param  {number} productId
+     * @param  {number} variantId
+     * @param  {string} metafieldKey
+     * @returns Promise Number of deleted metafields
+     */
+    public deleteMetafieldByKey = async (productId: number, variantId: number, metafieldKey: string): Promise<number> => {
+        try {
+            Logger.info(`ShopifyVariantService - deleteMetafieldByKey -> Deleting metafield Key ->  ${metafieldKey} for product ${productId} and variant ${variantId}`);
+            const metafields = await this.getMetafields(variantId);
+            let deleteItems = 0;
+            for (const metafield of metafields) {
+                if (metafield.key === metafieldKey) {
+                    await this.deleteMetafieldsByIds([metafield.id]);
+                    deleteItems++;
+                }
+            }
+            return deleteItems;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Deletes multiple metafields
+     * 
+     * @param  {number[]} productIds
+     * @returns Promise
+     */
+    public deleteMultipleMetafields = async (mertafieldsIds: number[]): Promise<any[]> => {
+        try {
+            if (mertafieldsIds && mertafieldsIds.length > 0) {
+                const errors = [];
+                Logger.info(`ShopifyVariantService - deleteMultipleMetafields -> Metafields to delete: ${mertafieldsIds.toString()}`);
+                const metafieldIdschunks: number[][] = this.sliceIntoChunks(mertafieldsIds, 50);
+                for (const metafieldIdsChunk of metafieldIdschunks) {
+                    const query = gql`mutation {
+                            ${metafieldIdsChunk.map((id) => (`
+                                metafield${id}: metafieldDelete(input: { id: "${this.getGraphMetafieldIdFromId(id)}" }) {
+                                    deletedId
+                                    userErrors {
+                                        field
+                                        message
+                                    }
+                                }`)).join('')}
+                        }`;
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 10 * metafieldIdsChunk.length });
+
+                    if (response && response.data && response.data.data) {
+                        const updatesResponse = response.data.data;
+                        for (const key in updatesResponse) {
+                            const err = updatesResponse[key].userErrors;
+                            if (err && err.length > 0) {
+                                errors.push(err);
+                            }
+                        }
+                    } else {
+                        errors.push('No response arrived');
+                    }
+                }
+                return errors;
+            } else {
+                Logger.info('ShopifyVariantService - deleteMultipleMetafields -> Remove metafields without IDs provided');
+                return [];
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Deletes a metafield by Key for a variant.
+     * 
+     * @param  {number} productId
+     * @param  {number} variantId
+     * @param  {string[]} metafieldKeys
+     * @returns Promise Number of deleted metafields
+     */
+    public deleteMetafieldByKeys = async (productId: number, variantId: number, metafieldKeys: string[]): Promise<number> => {
+        try {
+            Logger.info(`ShopifyVariantService - deleteMetafieldByKeys -> Deleting metafield Keys ->  ${JSON.stringify(metafieldKeys)} for product ${productId} and variant ${variantId}`);
+            const metafields = await this.getMetafields(variantId);
+            let deleteItems = 0;
+            const metafieldsTodelete: number[] = [];
+            for (const metafield of metafields) {
+                if (metafieldKeys.includes(metafield.key)) {
+                    metafieldsTodelete.push(metafield.id);
+                    deleteItems++;
+                }
+            }
+            if (metafieldsTodelete.length > 0) {
+                this.deleteMultipleMetafields(metafieldsTodelete);
+            }
+            return deleteItems;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Gets a metafield matching a product variant namespace and key.
+     * 
+     * @param  {number} productId
+     * @param  {string} namespace
+     * @param  {string} key (Max key allowed is 30 characters)
+     * @returns Promise
+     */
+    public getMetafield = async (productId: number, variantId: number, namespace: string, key: string): Promise<IMetafield> => {
+        try {
+            Logger.info(`ShopifyVariantService - getMetafield -> Getting metafield for product id -> ${productId} and variant ${variantId} and namespace ${namespace} and key ${key}`);
+            const metafields = await this.getMetafields(variantId);
+            let foundMetafield: IMetafield = null;
+            if (metafields && metafields.length > 0) {
+                foundMetafield = metafields.find(m => m.namespace === namespace && m.key === key);
+            }
+            return foundMetafield;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Adds metafields to variants
+     * 
+     * @param  {IVariantMetafield[]} variantMetafields
+     * @returns Promise Array of booleans taht says how the chuncks have been processed
+     */
+    public addMetafieldsToVariants = async (variantMetafields: IVariantMetafield[]): Promise<boolean[]> => {
+        try {
+            const chuncksResults: boolean[] = [];
+            Logger.info(`ShopifyVariantService - addMetafieldsToVariants -> Add metafields to variants: ${JSON.stringify(variantMetafields)}`);
+            const chuncks: IVariantMetafield[][] = this.sliceIntoChunks(variantMetafields, 50);
+            Logger.info(`ShopifyVariantService - addMetafieldsToVariants -> Add metafields to variants chuncks of 50: ${chuncks.length}`);
+            if (chuncks && chuncks.length > 0) {
+                for (const variantMetafieldsOfChunck of chuncks) {
+                    const variantsInput: { id: string; metafields: any[] }[] = [];
+                    for (const vM of variantMetafieldsOfChunck) {
+                        const variantInput = { id: `gid://shopify/ProductVariant/${vM.variant_id}`, metafields: [] };
+                        for (const m of vM.metafields) {
+                            const metafield = {
+                                namespace: m.namespace, key: m.key.length > 30 ? m.key.substring(0, 30) : m.key, value: `${m.value}`,
+                                type: this.getMetafieldType(m.type, m.value), description: m.description
+                            };
+                            if (m.id) {
+                                (metafield as any).id = `gid://shopify/Metafield/${m.id}`;
+                            }
+                            variantInput.metafields.push(metafield);
+                        }
+                        variantsInput.push(variantInput);
+                    }
+                    const rawQuery = `mutation variantsUpdate( ${variantMetafieldsOfChunck.map((variantMetafield) => (`$variant${variantMetafield.variant_id}: ProductVariantInput!`)).join(',')}){
+                            ${variantMetafieldsOfChunck.map((variantMetafield) => (`
+                                vMetafield${variantMetafield.variant_id}: productVariantUpdate(input: $variant${variantMetafield.variant_id}) {
+                                    productVariant { id }
+                                    userErrors { field message }
+                                }`)).join('')} }`;
+                    const query = gql`${rawQuery}`;
+                    Logger.info('addMetafieldsToVariants query:');
+                    Logger.info(rawQuery);
+                    const variables: any = {};
+                    for (const vM of variantMetafieldsOfChunck) {
+                        variables[`variant${vM.variant_id}`] = variantsInput.find((vI) => vI.id === `gid://shopify/ProductVariant/${vM.variant_id}`);
+                    }
+                    Logger.info('ShopifyVariantService - addMetafieldsToVariants -> addMetafieldsToVariants variables:');
+                    Logger.info(variables);
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(query), variables: variables }, { query_cost: 10 * variantMetafieldsOfChunck.length });
+                    if (response && response.data && response.data.data) {
+                        chuncksResults.push(true);
+                    } else {
+                        chuncksResults.push(false);
+                    }
+                }
+            }
+            return chuncksResults;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+}

package/shopify/router/ShopifyMandatoryRouter.ts

@@ -0,0 +1,37 @@
+import * as express from 'express';
+import { Logger } from '../../Logger';
+import { HmacUtils } from '../..';
+import { Request, Response } from 'express-serve-static-core';
+
+const router = express.Router();
+
+export class ShopifyMandatoryRouter {
+
+    constructor(private shopifySecret: string, private customerRedactcallback: ICustomerRedactCallback, private shopRedactcallback: IShopRedactCallback, private customersDataCallback: ICustomersDataCallback) { }
+
+    public buildRoutes(): express.Router {
+        router.post('/customers/redact', HmacUtils.jsonWebhookParser, (req, res) => { this.asyncFrame(req, res, this.customerRedactcallback); });
+        router.post('/customers/data_request', HmacUtils.jsonWebhookParser, (req, res) => { this.asyncFrame(req, res, this.customersDataCallback); });
+        router.post('/shop/redact', HmacUtils.jsonWebhookParser, (req, res) => { this.asyncFrame(req, res, this.shopRedactcallback); });
+        return router;
+    }
+
+    private asyncFrame = async (req: Request, res: Response, callback: (body: any) => Promise<express.Response | IOrder[]>): Promise<void> => {
+        return new Promise<void>(async (resolve, reject) => {
+            Logger.info('Mandatory webhook', req.body);
+            try {
+                const isHmacOk = await HmacUtils.checkHmac(req, this.shopifySecret);
+                if (!isHmacOk) throw 'Hmac not correct';
+                const response = await callback(req.body);
+                res.status(200).send(response);
+                resolve();
+            } catch (error) {
+                Logger.error(error);
+                res.status(401).send('HMAC validation failed');
+                reject(Error(error));
+            }
+        });
+    };
+}
+
+export default ShopifyMandatoryRouter;