@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyProductService.ts

@@ -0,0 +1,772 @@
+import { AxiosInstance } from 'axios';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { Logger } from '../Logger';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import { ShopifyProductServiceHelper } from './helpers/ShopifyProductServiceHelper';
+import { AbstractService } from './base/AbstractService';
+import { ShopifyProductPublicationsService } from './product/ShopifyProductPublicationsService';
+import { ShopifyProductCountService } from './product/ShopifyProductCountService';
+import { ShopifyProductListService } from './product/ShopifyProductListService';
+import ErrorHelper from './base/ErrorHelper';
+import { ShopifyProductMetafieldsService } from './product/ShopifyProductMetafieldsService';
+import { ShopifyVariantService } from './product/ShopifyVariantService';
+
+export class ShopifyProductService extends AbstractService {
+
+    public publications: ShopifyProductPublicationsService;
+    public count: ShopifyProductCountService;
+    public list: ShopifyProductListService;
+    public metafields: ShopifyProductMetafieldsService;
+    public variants: ShopifyVariantService;
+    private shopifyProductServiceHelper: ShopifyProductServiceHelper;
+
+    constructor(private axiosInstance: AxiosInstance) {
+        super();
+        this.publications = new ShopifyProductPublicationsService(axiosInstance);
+        this.count = new ShopifyProductCountService(axiosInstance);
+        this.list = new ShopifyProductListService(axiosInstance);
+        this.metafields = new ShopifyProductMetafieldsService(axiosInstance);
+        this.shopifyProductServiceHelper = new ShopifyProductServiceHelper();
+        this.variants = new ShopifyVariantService(axiosInstance, this.shopifyProductServiceHelper);
+    }
+
+    /**
+     * Product must specify the options names of the variants.<br>
+     * To assign images to variants the variants must have the image_id & product images list must have the variant_ids list.<br>
+     * Does not create more than 150 variants at a time.<br>
+     * Does not create more than 150 images.<br>
+     * When no locationID provided no stock is added.
+     * 
+     * 
+     * @param {IProduct} product 
+     * @param {number} locationId 
+     * @param {boolean} retrieveInventory 
+     * @returns created product 
+     */
+    public create = async (product: IProduct, locationId: number, retrieveInventory: boolean): Promise<IProduct> => {
+        try {
+            Logger.info('create', JSON.stringify(product));
+            const productCreateQuery = ShopifyProductServiceHelper.graphQLQuery.getProductCreateMutation(retrieveInventory);
+            const productToCreate: IProductCreateRequest = {};
+
+            const mediaToCreate: { alt: string; mediaContentType: 'EXTERNAL_VIDEO' | 'IMAGE' | 'VIDEO', originalSource: string; }[] = [];
+            const mediaToCreateForVarinats: { alt: string; mediaContentType: 'EXTERNAL_VIDEO' | 'IMAGE' | 'VIDEO', originalSource: string; }[] = [];
+            if (product.variants && product.variants.length > 0) {
+                productToCreate.productOptions = [];
+                if (product.variants[0].option1) {
+                    const optionValues: { name: string; }[] = [];
+                    for (const v of product.variants) {
+                        if (!optionValues.map(op => op.name).includes(v.option1)) {
+                            optionValues.push({ name: v.option1 });
+                        }
+                    }
+                    productToCreate.productOptions.push({ position: 1, name: product.options[0].name, values: optionValues });
+                }
+                if (product.variants[0].option2) {
+                    const optionValues: { name: string; }[] = [];
+                    for (const v of product.variants) {
+                        if (!optionValues.map(op => op.name).includes(v.option2)) {
+                            optionValues.push({ name: v.option2 });
+                        }
+                    }
+                    productToCreate.productOptions.push({ position: 2, name: product.options[1].name, values: optionValues });
+                }
+                if (product.variants[0].option3) {
+                    const optionValues: { name: string; }[] = [];
+                    for (const v of product.variants) {
+                        if (!optionValues.map(op => op.name).includes(v.option3)) {
+                            optionValues.push({ name: v.option3 });
+                        }
+                    }
+                    productToCreate.productOptions.push({ position: 3, name: product.options[2].name, values: optionValues });
+                }
+            }
+            if (product.vendor) {
+                productToCreate.vendor = product.vendor;
+            }
+            if (product.product_type) {
+                productToCreate.productType = product.product_type;
+            }
+            if (product.title) {
+                productToCreate.title = product.title;
+            }
+            if (product.tags) {
+                productToCreate.tags = Array.isArray(product.tags) ? product.tags : (product.tags ? product.tags.split(',').map(tag => tag.trim()) : []);
+            }
+            if (product.body_html) {
+                productToCreate.descriptionHtml = product.body_html;
+            }
+            if (product.images && product.images.length > 0) {
+                for (const img of product.images) {
+                    if (img.src) {
+                        if (!img.variant_ids || img.variant_ids.length === 0) {
+                            mediaToCreate.push({ mediaContentType: 'IMAGE', alt: '', originalSource: img.src.trim().replace(/ /g, '%20') });
+                        } else {
+                            mediaToCreateForVarinats.push({ mediaContentType: 'IMAGE', alt: '', originalSource: img.src.trim().replace(/ /g, '%20') });
+                        }
+                    }
+                }
+            }
+            productToCreate.status = 'ACTIVE';
+            if(product.status.toUpperCase() === 'ARCHIVED') {
+                productToCreate.status = 'ARCHIVED';
+            } else if(product.status.toUpperCase() === 'DRAFT') {
+                productToCreate.status = 'DRAFT';
+            }
+            Logger.info(`Product creating .... ${JSON.stringify(productToCreate)}`);
+            Logger.info(`Product media creating for no variant assigned .... ${JSON.stringify(mediaToCreate)}`);
+            Logger.info(`Product media creating for variants .... ${JSON.stringify(mediaToCreateForVarinats)}`);
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${productCreateQuery}`), variables: { product: productToCreate, media: mediaToCreate } }, { query_cost: 50 });
+
+            if (response && response.data && response.data.data && response.data.data.productCreate && response.data.data.productCreate.product) {
+                const productGraph: ShopifygraphQl.IGenericProductResponse = response.data.data.productCreate.product;
+
+                const createdProduct: IProduct = this.shopifyProductServiceHelper.getProduct(productGraph);
+                if (createdProduct && createdProduct.id) {
+                    Logger.info(`Product created with id ${createdProduct.id}`);
+                    const variantsToCreate: ShopifygraphQl.IVariantToPost[] = [];
+                    for (const variant of product.variants) {
+                        let imageSrc = '';
+                        if (variant.image_id) {
+                            const originalImage = product.images.find(i => i.id === variant.image_id);
+                            if (originalImage && originalImage.src) {
+                                imageSrc = originalImage.src;
+                            }
+                        }
+                        const variantToCreate: ShopifygraphQl.IVariantToPost = this.shopifyProductServiceHelper.getVariantToPost(variant, { imageSrc: imageSrc }, product.options.map(op => op.name), locationId);
+                        variantsToCreate.push(variantToCreate);
+                    }
+                    const variantsCreateQuery = ShopifyProductServiceHelper.graphQLQuery.getVariantsBulkCreateMutation(true, locationId ? true : false, true);
+                    Logger.info(`Product Variants create  .... ${JSON.stringify(variantsToCreate)}`);
+                    Logger.info(`Product Variants create query .... ${JSON.stringify(variantsCreateQuery)}`);
+                    const variantsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${variantsCreateQuery}`), variables: { productId: this.getGraphProductIdFromId(createdProduct.id), variants: variantsToCreate, media: mediaToCreateForVarinats } }, { query_cost: 50 });
+                    if (variantsResponse && variantsResponse.data && variantsResponse.data.data && variantsResponse.data.data.productVariantsBulkCreate && variantsResponse.data.data.productVariantsBulkCreate.productVariants) {
+                        createdProduct.variants = [];
+                        for (const graphVariant of variantsResponse.data.data.productVariantsBulkCreate.productVariants) {
+                            createdProduct.variants.push(this.shopifyProductServiceHelper.getVariant(graphVariant));
+                        }
+                    } else {
+                        Logger.error(`Product variants were not created. ${createdProduct.id}`);
+                    }
+                } else {
+                    Logger.error(`Product was not created. ${createdProduct.id}`);
+                }
+                return createdProduct;
+            } else {
+                throw new InspiraShopifyError({ message: JSON.stringify(response.data.errors) });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * @param {number} productId where to create the option
+     * @param {string} optionName
+     * @param {string[]} optionValues
+     * @param {number} position
+     */
+    public createOption = async (productId: number, optionName: string, optionValues: string[], position: number): Promise<boolean> => {
+        try {
+            Logger.info(`ShopifyVariantService - createOption -> option Name ${optionName} --- position ${position} --- optionValues ${JSON.stringify(optionValues)}`);
+
+            const optionCreateQuery = ShopifyProductServiceHelper.graphQLQuery.productOptionCreateMutation();
+            Logger.info(`ShopifyVariantService - createOption -> query  .... ${JSON.stringify(optionCreateQuery)}`);
+            const variables = { productId: this.getGraphProductIdFromId(productId), options: [{ name: optionName, position: position, values: optionValues.map(v => ({ name: v })) }] };
+            Logger.info(`ShopifyVariantService - createOption -> variables .... ${JSON.stringify(variables)}`);
+
+            const optionsResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${optionCreateQuery}`), variables: variables }, { query_cost: 50 });
+            let isOptionCreated = false;
+            if (optionsResponse && optionsResponse.data && optionsResponse.data.data && optionsResponse.data.data.productOptionsCreate) {
+                isOptionCreated = true;
+            } else {
+                Logger.error(`ShopifyVariantService - createOption -> ${optionsResponse.data.data}`);
+            }
+            return isOptionCreated;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    public update = async (product: IProductUpdateRequest): Promise<void> => {
+        try {
+            Logger.info(`update product with id ${product.id}`, product);
+            const productUpdateQuery = ShopifyProductServiceHelper.graphQLQuery.updateProductMutation;
+            if (`${product.id}`.indexOf('gid') === -1) {
+                product.id = this.getGraphProductIdFromId(product.id as number);
+            }
+            Logger.info(`Product update query .... ${JSON.stringify(productUpdateQuery)}`);
+            Logger.info(`Product update variable .... ${JSON.stringify(product)}`);
+            const productUpdateResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${productUpdateQuery}`), variables: { product: product } }, { query_cost: 10 });
+            if (!productUpdateResponse?.data?.data?.productUpdate?.product?.id) {
+                Logger.error(`Product did not update ${JSON.stringify(productUpdateResponse?.data?.data)}`);
+                throw new InspiraShopifyError({ message: `Product did not update ${JSON.stringify(productUpdateResponse?.data?.data?.productUpdate?.userErrors)}` });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * @param cursor in the first request send null
+     * @param metafields 
+     * @returns array of elements or empty array
+     */
+    public getProductsWithMetafiledsInBatch = async (cursor: string, metafields: { namespace: string; key: string; }[]): Promise<IProductMetafieldInBatch[]> => {
+        try {
+            if (metafields && metafields.length > 0) {
+                Logger.info(`Get product with metafields from cursor: ${cursor}`);
+                const numOfProductsToGet = parseInt(`${200 / metafields.length}`, 10);
+                const query = gql`{ 
+                        products(first: ${numOfProductsToGet}${cursor ? `,after: "${cursor}"` : ''}) {
+                            edges {
+                                cursor
+                                node {
+                                    id
+                                    ${metafields.map((m, i) => (`m${i}: metafield(namespace: "${m.namespace}", key: "${m.key}") {
+                                        value
+                                    }`)).join('')}
+                                }
+                            }
+                        }
+                    }`;
+                const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: numOfProductsToGet * 2 * metafields.length });
+                if (response && response.data && response.data.data && response.data.data.products) {
+                    const productsGraph = response.data.data.products.edges;
+                    const productsWithMetafields = productsGraph.map((p: any) => ({ id: this.getIdFromGraphId(p.node.id), cursor: p.cursor, metafields: metafields.map((m, i) => ({ namespace: m.namespace, key: m.key, value: p.node[`m${i}`] ? p.node[`m${i}`].value : null })) }));
+                    return productsWithMetafields;
+                } else {
+                    throw new InspiraShopifyError({ message: JSON.stringify(response.data.errors) });
+                }
+            } else {
+                Logger.info('No metafields provided');
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Gets a product By Id with only stock information.
+     * 
+     * @param  {number} productId
+     * @returns Promise
+     */
+    public getProductWithStockInfoById = async (productId: number): Promise<IProductStocks> => {
+        try {
+            Logger.info(`Get product stock with ID: ${productId}`);
+            const productStock: IProductStocks = await this.getProductWithStockInfoByIdFromCursor(productId, 50, null);
+            let lastVariantsSize: number = productStock.variants.length;
+            while (lastVariantsSize >= 50) {
+                const productStockAlt: IProductStocks = await this.getProductWithStockInfoByIdFromCursor(productId, 50, productStock.variants[productStock.variants.length - 1].cursor);
+                lastVariantsSize = productStockAlt.variants.length;
+                productStock.variants = productStock.variants.concat(productStockAlt.variants);
+            }
+            return productStock;
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Gets a product By Id with only stock information with 50 variants. Starts on a variant specified cursor from another search.
+     * 
+     * @param  {number} productId
+     * @returns Promise
+     */
+    public getProductWithStockInfoByIdFromCursor = async (productId: number, numOfVariants: number, cursor: string): Promise<IProductStocks> => {
+        try {
+            Logger.info(`getProductWithStockInfoByIdFromCursor -> Get product stock with ID: ${productId} num of variants ${numOfVariants} and cursor ${cursor}`);
+            const query = gql`{ 
+                    product(id: "${this.getGraphProductIdFromId(productId)}")  {
+                        id
+                        variants(first: ${numOfVariants}, ${cursor ? `after: "${cursor}"` : ''}) {
+                            edges {
+                                cursor
+                                node {
+                                    id
+                                    inventoryQuantity
+                                    inventoryPolicy
+                                    inventoryItem {
+                                        id
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 110 });
+            if (response && response.data && response.data.data && response.data.data.product) {
+                const productGraph = response.data.data.product;
+                return {
+                    id: productId, variants: productGraph.variants.edges.map((gv) => ({
+                        id: this.getIdFromGraphId(gv.node.id),
+                        cursor: gv.cursor,
+                        inventory_quantity: gv.node.inventoryQuantity,
+                        inventory_policy: gv.node.inventoryPolicy,
+                        inventory_item_id: this.getIdFromGraphId(gv.node.inventoryItem.id)
+                    } as IVariantStock))
+                };
+            } else {
+                return null;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Add tags to a list of products.
+     * 
+     * @param  {number[]} productIds
+     * @returns Promise
+     */
+    public addTagsToProducts = async (productIds: number[], tagsToAdd: string): Promise<any[]> => {
+        try {
+            if (productIds && productIds.length > 0) {
+                const errors = [];
+                Logger.info(`Add tags to products: ${productIds.toString()}`);
+                const productIdschunks: number[][] = this.sliceIntoChunks(productIds, 30);
+                for (const productIdsChunk of productIdschunks) {
+                    Logger.info(`Add tags to products chunck with: ${productIdsChunk.length} products `);
+                    const query = gql`mutation {
+                            ${productIdsChunk.map((id) => (`
+                                Product${id}: tagsAdd(id: "${this.getGraphProductIdFromId(id)}", tags: "${this.escapeQuotes(tagsToAdd)}") {
+                                    node {
+                                        id
+                                    }
+                                    userErrors {
+                                        field
+                                        message
+                                    }
+                                }`)).join('')}
+                        }`;
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: productIdsChunk.length * 15 });
+
+                    Logger.info(`Add tags to products response: ${JSON.stringify(response.data)} `);
+                    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('Add tags to products without product IDs provided');
+                return [];
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Remove tags to a list of products
+     * 
+     * @param  {number[]} productIds
+     * @returns Promise
+     */
+    public removeTagsToProducts = async (productIds: number[], tagsToRemove: string): Promise<any[]> => {
+        try {
+            if (productIds && productIds.length > 0) {
+                const errors = [];
+                Logger.info(`Remove tags to products: ${productIds.toString()}`);
+                const productIdschunks: number[][] = this.sliceIntoChunks(productIds, 30);
+                for (const productIdsChunk of productIdschunks) {
+                    const query = gql`mutation { ${productIdsChunk.map((id) => (`
+                                Product${id}: tagsRemove(id: "${this.getGraphProductIdFromId(id)}", tags: "${this.escapeQuotes(tagsToRemove)}") {
+                                    node {
+                                        id
+                                    }
+                                    userErrors {
+                                        field
+                                        message
+                                    }
+                                }`)).join('')}
+                        }`;
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: productIdsChunk.length * 15 });
+                    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('Remove tags to products without Product IDs');
+                return [];
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Gets a product By Id with only stock information. It retrieves up to 20 variants and 20 invenotry items ids
+     * 
+     * @param  {number} productId
+     * @returns Promise
+     */
+    public getProductWithInventoryInfoById = async (productId: number): Promise<IProductInventory> => {
+        try {
+            Logger.info(`Get product Inventory stock with ID: ${productId}`);
+            const query = gql` { 
+                    product(id: "${this.getGraphProductIdFromId(productId)}")  {
+                        id
+                        variants(first: 20) {
+                            edges {
+                                node {
+                                    id
+                                    price
+                                    sku
+                                    availableForSale
+                                    inventoryQuantity
+                                    inventoryPolicy
+                                    inventoryItem {
+                                        id
+                                        tracked
+                                        unitCost {
+                                            amount
+                                        }
+                                        inventoryLevels(first: 20) {
+                                            edges {
+                                                node {
+                                                    quantities(names:["available"]){
+                                                        quantity
+                                                    }
+                                                    location {
+                                                        id
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 883 });
+            if (response && response.data && response.data.data && response.data.data.product) {
+                const productGraph = response.data.data.product;
+                return {
+                    id: productId,
+                    variants: productGraph.variants.edges.map((gv) => ({
+                        id: this.getIdFromGraphId(gv.node.id),
+                        inventory_quantity: gv.node.inventoryQuantity,
+                        inventory_policy: gv.node.inventoryPolicy,
+                        sku: gv.node.sku,
+                        available_for_sale: gv.node.availableForSale,
+                        inventory_item_id: this.getIdFromGraphId(gv.node.inventoryItem.id),
+                        inventory_item: {
+                            id: this.getIdFromGraphId(gv.node.inventoryItem.id),
+                            tracked: gv.node.inventoryItem.tracked,
+                            cost: gv.node.inventoryItem.unitCost ? gv.node.inventoryItem.unitCost.amount : null,
+                            levels: gv.node.inventoryItem.inventoryLevels.edges.map((gl) => ({
+                                location_id: this.getIdFromGraphId(gl.node.location.id),
+                                id: this.getIdFromGraphId(gl.node.id),
+                                available: gl.node.quantities && gl.node.quantities[0] ? gl.node.quantities[0].quantity : 0,
+                                inventory_item_id: this.getIdFromGraphId(gv.node.inventoryItem.id)
+                            } as IInventoryLevel)
+                            )
+                        } as IInventoryItem
+                    } as IVariantInventory)
+                    )
+                };
+            } else {
+                Logger.error(`getProductWithInventoryInfoById not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}`);
+                return null;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Gets a product By SKU
+     * 
+     * @param  {string} sku
+     * @returns Promise<IProduct[]>
+     */
+    public getBySKU = async (sku: string): Promise<IProduct[]> => {
+        try {
+            Logger.info(`getBySKU - Get Product by SKU - ${sku}`);
+            const query = gql`query {
+                    products(first: 10, query: "sku:${sku}") {
+                        id
+                        title
+                        vendor
+                        handle
+                        productType
+                        tags
+                        publishedAt
+                        updatedAt
+                        hasOnlyDefaultVariant
+                        isGiftCard
+                        status
+                    }
+                }`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) });
+            Logger.info(`getBySKU - Get Product by SKU - Query Response - ${response}`);
+            if (response && response.data && response.data.data && response.data.data.products) {
+                const productsGraph = response.data.data.products.nodes;
+                const mappedResponse: IProduct[] = productsGraph.map(el => ({
+                    id: el.id,
+                    title: el.title,
+                    vendor: el.vendor,
+                    handle: el.handle,
+                    productType: el.productType,
+                    tags: el.tags,
+                    publishedAt: el.publishedAt,
+                    updatedAt: el.updatedAt,
+                    hasOnlyDefaultVariant: el.hasOnlyDefaultVariant,
+                    isGiftCard: el.isGiftCard,
+                    status: el.status,
+                }));
+                return mappedResponse;
+            } else {
+                throw new InspiraShopifyError({ message: JSON.stringify(response.data.errors) });
+            }
+        } catch (error) {
+            this.logErrorAndThrow(error);
+        }
+    };
+
+    public delete = async (id: number): Promise<void> => {
+        try {
+            Logger.info(`ShopifyProductService - delete -> ${id}`);
+            const rawQuery = `mutation {
+                    productDelete(input: { id: "${this.getGraphProductIdFromId(id)}"}) {
+                        deletedProductId
+                        userErrors {
+                            field
+                            message
+                        }
+                    }
+                }`;
+            Logger.info(`ShopifyProductService - delete -> rawQuery ${rawQuery}`);
+            const query = gql`${rawQuery}`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 10 });
+            if (response && response.data && response.data.data && response.data.data.productDelete) {
+                return;
+            } else {
+                Logger.error(`ShopifyProductService - delete -> Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}`);
+                throw new InspiraShopifyError({ message: `Product was not deleted - ${JSON.stringify(response.data.errors)}` });
+            }
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    public getProductsByIdsWithCollectionsInfo = async (ids: number[], collectionIds: number[]): Promise<IProductCollection[]> => {
+        try {
+            Logger.info(`getProductsByIdsWithCollectionsInfo: productIds ${ids} collectionIds: ${collectionIds}`);
+            const rawQuery = ` { 
+                    products(first: 50, query: "${ids.map(id => `(id:${id})`).join(' OR ')}") {
+                        edges {
+                            node {
+                                id
+                                tags
+                                vendor
+                                productType
+                                ${collectionIds.map(cId => `
+                                    c_${cId}: inCollection(id: "gid://shopify/Collection/${cId}")`).join('')}
+                            }
+                        }
+                    }
+                }`;
+            Logger.info(`getProductsByIdsWithCollectionsInfo - rawQuery ${rawQuery}`);
+            const query = gql`${rawQuery}`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 900 });
+            if (response && response.data && response.data.data && response.data.data.products) {
+                const productsGraph: IProductCollection[] = response.data.data.products.edges.map(p => {
+                    const product: IProductCollection = { id: this.getIdFromGraphId(p.node.id), vendor: p.node.vendor, productType: p.node.productType, tags: p.node.tags, collectionsContained: collectionIds.map(cId => p.node[`c_${cId}`] ? cId : null).filter(c => c !== null) };
+                    return product;
+                });
+                return productsGraph;
+            } else {
+                Logger.error(`getProductsByIdsWithCollectionsInfo not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}`);
+                return null;
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Finds product by titleand returns the first 100 matches.
+     * 
+     * @param  {string} title
+     * 
+     * @returns Promise
+     */
+    public searchByTitle = async (title: string): Promise<{ title: string; id: number; handle: string; image: string; variants_count: number; variants: { id: number; title: string; }; }[]> => {
+        try {
+            Logger.info(`searchByTitle ${title}`);
+            const metafieldQuery = gql`query {
+                products(first: 100, query: "title:*${title}*") {
+                    edges {
+                        node {
+                            title
+                            id
+                            handle
+                            featuredImage {
+                                url
+                            }
+                            variants(first: 100) {
+                                edges {
+                                    node {
+                                        id
+                                        title
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }  
+            }`;
+
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), variables: {} }, { query_cost: 200 });
+
+            if (response && response.data && response.data.data && response.data.data.products && response.data.data.products.edges.length > 0) {
+                return response.data.data.products.edges.map((p) => ({ id: this.getIdFromGraphId(p.node.id), title: p.node.title, handle: p.node.handle, image: p.node.featuredImage ? p.node.featuredImage.url : '', variants_count: p.node.variants.edges.length, variants: p.node.variants.edges.map(v => ({ id: this.getIdFromGraphId(v.node.id), title: v.node.title })) }));
+            } else {
+                return [];
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * Create a product image and link it to variants.
+     * 
+     * @param  {number} productId - product ID
+     * @param  { alt: string; src: string; } img of image
+     * @param  {number[]} variantIds of image
+     * 
+     * @returns Promise
+     */
+    public createImage = async (productId: number, img: { alt?: string; src: string; }, variantIds: number[]): Promise<void> => {
+        try {
+            if (img.src) {
+                Logger.info(`Creating image for product id ->  ${productId}, src ${img.src} for variants ${variantIds}`);
+                if (variantIds?.length > 0) {
+                    const rawQuery = `mutation productVariantsBulkUpdate($productId: ID!, $variants: [ProductVariantsBulkInput!]!, $media: [CreateMediaInput!]) {
+                        productVariantsBulkUpdate(productId: $productId, variants: $variants, media: $media)
+                            { product { id }
+                        }
+                    }`;
+                    const addImageResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`), variables: { productId: this.getGraphProductIdFromId(productId), variants: variantIds.map(vid => ({ id: this.getGraphProductVariantIdFromId(vid), mediaSrc: [img.src] })), media: [{ originalSource: img.src.trim().replace(/ /g, '%20'), mediaContentType: 'IMAGE', alt: img.alt ? img.alt : '' }] } }, { query_cost: 60 });
+                    if (addImageResponse && addImageResponse.data && addImageResponse.data.data?.productVariantsBulkUpdate.product?.id) {
+                        Logger.info(`Added image ${img.src} to products ${productId} and linke to variants ${variantIds}`);
+                    } else {
+                        throw new InspiraShopifyError({ message: `No images have been added to product ${productId} - response ${JSON.stringify(addImageResponse.data)}` });
+                    }
+                } else {
+                    const rawQuery = `mutation productUpdate($input: ProductInput!, $media: [CreateMediaInput!]) {
+                        productUpdate(input: $input, media: $media)
+                            { product {
+                                media(first: 5, sortKey: ID ) {
+                                    nodes {
+                                        id
+                                        alt
+                                        mediaContentType
+                                        preview {
+                                            status
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }`;
+                    const addImageResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`), variables: { input: { id: this.getGraphProductIdFromId(productId) }, media: [{ originalSource: img.src.trim().replace(/ /g, '%20'), mediaContentType: 'IMAGE', alt: img.alt ? img.alt : '' }] } }, { query_cost: 60 });
+
+                    if (addImageResponse && addImageResponse.data && addImageResponse.data.data?.productUpdate && addImageResponse.data.data?.productUpdate?.product) {
+                        Logger.info(`Added image ${img.src} to products ${productId}`);
+                    } else {
+                        throw new InspiraShopifyError({ message: `No images have been added to product ${productId} - response ${JSON.stringify(addImageResponse.data)}` });
+                    }
+                }
+
+            } else {
+                throw new InspiraShopifyError({ message: `No image source provided to add to product ${productId}` });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * Create a product image and link it to variants.
+     * 
+     * @param  {number} productId - product ID
+     * 
+     * @returns Promise
+     */
+    public deleteMedia = async (productId: number): Promise<void> => {
+        try {
+            Logger.info(`Delete product Media product id ->  ${productId}`);
+            const media = await this.getMedia(productId);
+            if (media.length) {
+                const rawQuery = `mutation productDeleteMedia($mediaIds: [ID!]!, $productId: ID!) {
+                    productDeleteMedia(mediaIds: $mediaIds, productId: $productId) {
+                        deletedMediaIds
+                        deletedProductImageIds
+                        mediaUserErrors {
+                            field
+                            message
+                        }
+                        product {
+                            id
+                            title
+                            media(first: 5) {
+                                nodes {
+                                    alt
+                                    mediaContentType
+                                    status
+                                }
+                            }
+                        }
+                    }
+                }`;
+                const deleteImageResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`), variables: { mediaIds: media.map(m => m.id), productId: this.getGraphProductIdFromId(productId) } }, { query_cost: 60 });
+
+                if (deleteImageResponse && deleteImageResponse.data && deleteImageResponse.data.data?.productDeleteMedia && deleteImageResponse.data.data?.productDeleteMedia) {
+                    Logger.info(`Deleted media from product ${productId}. Images deleted -> ${deleteImageResponse.data.data?.productDeleteMedia.deletedProductImageIds}. Media deleted -> ${deleteImageResponse.data.data?.productDeleteMedia.deletedMediaIds}`);
+                } else {
+                    throw new InspiraShopifyError({ message: `No images have been deleted on product ${productId} - response ${JSON.stringify(deleteImageResponse.data)}` });
+                }
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * Returns media of a product. Max of 250
+     * 
+     * @param  {number} productId - product ID
+     * 
+     * @returns Promise
+     */
+    public getMedia = async (productId: number): Promise<{ id: string; mediaContentType: 'IMAGE' | 'VIDEO'; }[]> => {
+        try {
+            Logger.info(`Get product Media product id ->  ${productId}`);
+            const rawQuery = `query ProductMedia($productId: ID!) {
+                product(id: $productId) {
+                    media(first: 250) {
+                        edges {
+                            node {
+                                id
+                                mediaContentType
+                            }
+                        }
+                    }
+                }
+            }`;
+            const getMediaResponse = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`), variables: { productId: this.getGraphProductIdFromId(productId) } }, { query_cost: 60 });
+
+            if (getMediaResponse && getMediaResponse.data && getMediaResponse.data.data?.product && getMediaResponse.data.data?.product) {
+                Logger.info(`Get media from product ${productId}. ${JSON.stringify(getMediaResponse.data.data)}`);
+                if (getMediaResponse.data.data?.product?.media?.edges?.length > 0) {
+                    return getMediaResponse.data.data?.product?.media?.edges.map((edge: { node: { id: string; mediaContentType: string; } }) => edge.node);
+                } else {
+                    return [];
+                }
+            } else {
+                throw new InspiraShopifyError({ message: `No images could be retrieved for product ${productId} - response ${JSON.stringify(getMediaResponse.data)}` });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+}