@sommpicks/sommpicks-shopify 24.12.0

package/shopify/product/ShopifyProductMetafieldsService.ts

@@ -0,0 +1,405 @@
+import { AxiosInstance } from 'axios';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { AbstractService } from '../base/AbstractService';
+import { Logger } from '../../Logger';
+import InspiraShopifyError from '../errors/InspiraShopifyError';
+import ErrorHelper from '../base/ErrorHelper';
+
+export class ShopifyProductMetafieldsService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { super(); }
+
+    /**
+    * Gets All metafields of a product (Max of 200)
+    * 
+    * @param  {number} productId
+    * @returns Promise
+    */
+    public getMetafields = async (productId: number): Promise<IMetafield[]> => {
+        try {
+            Logger.info(`ShopifyProductService - getMetafields -> Getting metafields for product id ->  ${productId}`);
+            const rawQuery = ` {
+                    product(id: "gid://shopify/Product/${productId}")  {
+                        id
+                        metafields(first: 200) {
+                            nodes {
+                                key
+                                namespace
+                                value
+                                id
+                                description
+                                type
+                            }
+                        }
+                    }
+                }`;
+            const query = gql`${rawQuery}`;
+            Logger.info(`ShopifyProductService - getMetafields -> rawQuery ${rawQuery}`);
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 20 });
+            if (response.data.data.product) {
+                if (response.data.data.product.metafields) {
+                    if (response.data.data.product.metafields.nodes && response.data.data.product.metafields.nodes.length > 0) {
+                        const metafieldsNodes: IMetafieldGraphQL[] = response.data.data.product.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 {
+                        return [];
+                    }
+                } else {
+                    Logger.error(`ShopifyProductService - getMetafields -> not the expected response. Data ${JSON.stringify(response.data.data)}. Error is ${JSON.stringify(response.data.errors)}`);
+                    return [];
+                }
+            } else {
+                return [];
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * 
+     * Adds or updates a metafield.
+     * Metafield type, key, namespace and value must be set
+     * 
+     * @param  {number} id - product ID
+     * @param  {IMetafield[]} metafields to be saved
+     * @returns Promise
+     */
+    public saveOrUpdateMetafields = async (id: number, metafields: IMetafield[]): Promise<IMetafield[]> => {
+        try {
+            Logger.info(`ShopifyProductService - saveOrUpdateMetafields -> for product id ->  ${id}`);
+
+            const metafieldsChunks = this.sliceIntoChunks(metafields, 20);
+
+            if (metafields?.length) {
+                for (const [index, metafiledsChunk] of metafieldsChunks.entries()) {
+                    Logger.info(`ShopifyProductService - saveOrUpdateMetafields -> processing chunck ${index}`);
+                    const metafieldsToPost: IMetafieldCreate_GraphQL[] = metafiledsChunk.map(m => ({ ownerId: this.getGraphProductIdFromId(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(`ShopifyProductService - saveOrUpdateMetafields -> ${rawQuery}`);
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`), variables: { metafields: metafieldsToPost } }, { query_cost: 10 * metafiledsChunk.length });
+                    Logger.info(`ShopifyProductService - 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(`ShopifyProductService - saveOrUpdateMetafields ->  ${JSON.stringify(response?.data?.data?.metafieldsSet?.userErrors)}`);
+                            throw new InspiraShopifyError({ message: JSON.stringify(response.data?.data?.metafieldsSet?.userErrors) });
+                        } else {
+                            return [];
+                        }
+                    }
+                }
+            } else {
+                Logger.info(`ShopifyProductService - saveOrUpdateMetafields -> for product id ->  ${id} - no metafields provided`);
+            }
+
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    /**
+    * Add a metafield to a product for multiple metafield product updates.
+    * 
+    * @param  {IMetafieldOfProduct[]} metafieldForProducts
+    * @returns Promise
+    */
+    public addMetafieldForProducts = async (metafieldForProducts: IMetafieldOfProduct[]): Promise<number[]> => {
+        return new Promise<number[]>(async (resolve, reject) => {
+            try {
+                const productIds: number[] = [];
+                const metafieldForProductschunks: IMetafieldOfProduct[][] = this.sliceIntoChunks(metafieldForProducts, 5);
+                for (const metafieldForProductsChunk of metafieldForProductschunks) {
+
+                    const rawQuery: string = `{
+                        ${metafieldForProductsChunk.map((mForProduct) => (`
+                            product${mForProduct.product_id}: product( id: "${this.getGraphProductIdFromId(mForProduct.product_id)}") {
+                                metafield1: metafield(
+                                    namespace: "${mForProduct.namespace.trim()}"
+                                    key: "${mForProduct.key.trim()}"
+                                ) {
+                                    value
+                                    key
+                                    namespace
+                                    id
+                                }
+                            }
+                        `)).join('')} }`;
+                    Logger.info('ExistingMetafields - raw query ', rawQuery);
+                    const responseOfExistingMetafields = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`) }, { query_cost: 30 * metafieldForProductsChunk.length });
+                    const existingMetafieldForProduct: IMetafieldOfProduct[] = [];
+                    Logger.info('responseOfExistingMetafields - ', JSON.stringify(responseOfExistingMetafields.data));
+                    if (responseOfExistingMetafields.data.errors && responseOfExistingMetafields.data.errors.length > 0) {
+                        Logger.error('responseOfExistingMetafields with errors - ', JSON.stringify(responseOfExistingMetafields.data));
+                        throw new Error(`${JSON.stringify(responseOfExistingMetafields.data.errors)} - responseOfExistingMetafields - ${JSON.stringify(rawQuery)}`);
+                    } else if (responseOfExistingMetafields.data && responseOfExistingMetafields.data.data) {
+                        for (const mForProduct of metafieldForProductsChunk) {
+                            const product = responseOfExistingMetafields.data.data[`product${mForProduct.product_id}`];
+                            if (product && product.metafield1) {
+                                existingMetafieldForProduct.push({
+                                    key: product.metafield1.key,
+                                    value: product.metafield1.value,
+                                    namespace: product.metafield1.namespace,
+                                    id: this.getIdFromGraphId(product.metafield1.id),
+                                    product_id: mForProduct.product_id
+                                });
+                            }
+                        }
+                        if (existingMetafieldForProduct && existingMetafieldForProduct.length > 0) {
+                            for (const metaForproduct of metafieldForProductsChunk) {
+                                if (metaForproduct.product_id) {
+                                    const existingMetafield = existingMetafieldForProduct.find((em) => em.product_id === metaForproduct.product_id);
+                                    if (existingMetafield) {
+                                        metaForproduct.id = existingMetafield.id;
+                                    }
+                                }
+                            }
+                        }
+                        const rawQuery = `mutation {
+                            ${metafieldForProductsChunk.map((mForProduct) => (`
+                            product${mForProduct.product_id}: productUpdate(input: { id: "${this.getGraphProductIdFromId(mForProduct.product_id)}",
+                                                metafields: [{ namespace: "${mForProduct.namespace.trim()}", key: "${mForProduct.key.trim()}", value: "${this.escapeQuotes(mForProduct.value)}", type: "${this.getMetafieldType(mForProduct.type, mForProduct.value)}",
+                                                                description: "${this.escapeQuotes(mForProduct.description)}" ${mForProduct.id ? `, id: "${this.getGraphMetafieldIdFromId(mForProduct.id)}"` : ''}}
+                                                            ]
+                                                })
+                                    { product {
+                                        id
+                                    }
+                                }`)).join('')} }`;
+                        Logger.info('ExistingMetafields - raw query - update ', rawQuery);
+                        const response = await this.axiosInstance.post('/graphql.json', { query: print(gql`${rawQuery}`) }, { query_cost: 40 * metafieldForProductsChunk.length });
+                        Logger.info('response updated Metafields - ', JSON.stringify(response.data));
+                        if (response.data.errors && response.data.errors.length > 0) {
+                            Logger.error('response updated Metafields with errors - ', JSON.stringify(response.data));
+                            throw new Error(`${JSON.stringify(response.data.errors)} - response updated Metafields - ${JSON.stringify(rawQuery)}`);
+                        } else if (response.data && response.data.data) {
+                            for (const key in response.data.data) {
+                                const product = response.data.data[key];
+                                productIds.push(this.getIdFromGraphId(product.product.id));
+                            }
+                        }
+                    }
+                }
+                resolve(productIds);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Adds Multiple metafields in a product. If the metafield id is provided then it will also update the metafield.
+     * 
+     * @param  {number} id - product ID
+     * @param  {IMetafield[]} metafields to be saved
+     * @param  {boolean} mergeMetafields when merge Metafields is set to true. It will try to merge metafields even though they do not have a Id setup.
+     * @param  {boolean} deleteMissingMergedMetafields only affects when merge Metafields is set to true. It will remove existing metafields not been able to get merged.
+     * @returns Promise
+     */
+    public addMetafieldsForAProduct = async (id: number, metafields: IMetafield[], mergeMetafields: boolean, deleteMissingMergedMetafields: boolean): Promise<IMetafield[]> => {
+        return new Promise<IMetafield[]>(async (resolve, reject) => {
+            try {
+                Logger.info(`Add ${metafields.length} Metafields to product: ${id}`);
+
+                const productMetafieldsInput = { id: this.getGraphProductIdFromId(id), metafields: [] };
+                let productExistingMetafields: IMetafield[] = [];
+
+                if (mergeMetafields) { productExistingMetafields = await this.getMetafields(id); }
+
+                let metafieldIndex = 0;
+
+                for (const metafield of metafields) {
+                    productMetafieldsInput.metafields.push({
+                        namespace: metafield.namespace, key: metafield.key, value: `${metafield.value}`,
+                        type: this.getMetafieldType(metafield.type, metafield.value), description: metafield.description
+                    });
+                    if (metafield.id) {
+                        productMetafieldsInput.metafields[metafieldIndex].id = this.getGraphMetafieldIdFromId(metafield.id);
+                    } else {
+                        const existingMetafield = productExistingMetafields.find((m) => m.key === metafield.key && m.namespace === metafield.namespace);
+                        if (existingMetafield) {
+                            productMetafieldsInput.metafields[metafieldIndex].id = this.getGraphMetafieldIdFromId(existingMetafield.id);
+                        }
+                    }
+                    metafieldIndex++;
+                }
+
+                if (deleteMissingMergedMetafields && productExistingMetafields && productExistingMetafields.length > 0) {
+                    Logger.info(`Finding metafields to be deleted from product ${id}. Metafields ${JSON.stringify(productExistingMetafields)}`);
+                    for (const met of productExistingMetafields) {
+                        const mergedMet = productMetafieldsInput.metafields.find((m) => m.id === this.getGraphMetafieldIdFromId(met.id));
+                        if (!mergedMet) {
+                            try {
+                                Logger.info(`Deleteing metafield ${met.id} from product ${id}`);
+                                await this.deleteMetafieldsByIds(id, [met.id]);
+                            } catch (e) {
+                                Logger.error('We could not delete the metafield. Keep going ...', e.message);
+                            }
+                        }
+                    }
+                }
+
+                const rawQuery = `mutation productUpdate($input: ProductInput!) {
+                    productUpdate(input: $input)
+                        { product {
+                            metafields(first: 100) {
+                                edges {
+                                    node {
+                                        id
+                                        namespace
+                                        key
+                                        value
+                                        description
+                                        type
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }`;
+
+                Logger.info('addMetafieldsForAProduct query:');
+                Logger.info(rawQuery);
+                Logger.info('addMetafieldsForAProduct variable:');
+                Logger.info(productMetafieldsInput);
+                const query = gql`${rawQuery}`;
+
+                if (productMetafieldsInput.metafields.length > 0) {
+                    const response = await this.axiosInstance.post('/graphql.json', { query: print(query), variables: { input: productMetafieldsInput } }, { query_cost: 112 });
+                    if (response && response.data && response.data.data && response.data.data.productUpdate) {
+                        try {
+                            const metafields: IMetafield[] = [];
+                            for (const edge of response.data.data.productUpdate.product.metafields.edges) {
+                                metafields.push({
+                                    id: this.getIdFromGraphId(edge.node.id), value: edge.node.value, type: this.getMetafieldType(edge.node.type, edge.node.value),
+                                    description: edge.node.description, namespace: edge.node.namespace, key: edge.node.key
+                                });
+                            }
+                            resolve(metafields);
+                        } catch (e) {
+                            resolve([]);
+                        }
+                    } else {
+                        resolve([]);
+                    }
+                } else {
+                    resolve([]);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Deletes a metafields by namespace for a product.
+     * 
+     * @param  {number} productId
+     * @param  {string} namespace
+     * @returns Promise number of deleted metafields
+     */
+    public deleteMetafieldsByNamespace = async (productId: number, namespace: string): Promise<number> => {
+        try {
+            Logger.info(`Deleting metafield by namespace ->  ${namespace} for product ${productId}`);
+            const metafields = await this.getMetafields(productId);
+            const metafieldsToDelete = metafields.filter((m) => m.namespace === namespace);
+
+            const query = gql`mutation metafieldsDelete($metafields: [MetafieldIdentifierInput!]!) {
+                    metafieldsDelete(metafields: $metafields) {
+                        deletedMetafields {
+                            key
+                            ownerId
+                        }
+                        userErrors {
+                            field
+                            message
+                        }
+                    }
+                }`;
+            const metafiedlsToDeleteVar = metafieldsToDelete.map((m) => ({ ownerId: this.getGraphProductIdFromId(productId), namespace: namespace, key: m.key }));
+            const metafieldsDeleteResponse = await this.axiosInstance.post('/graphql.json', { query: print(query), variables: { metafields: metafiedlsToDeleteVar } }, { query_cost: 10 * metafieldsToDelete.length });
+            console.log(JSON.stringify(metafieldsDeleteResponse.data));
+            if (metafieldsDeleteResponse.data?.data?.metafieldsDelete?.deletedMetafields) {
+                let numDeleted = 0;
+                // eslint-disable-next-line no-unsafe-optional-chaining
+                for (const metaId of metafieldsDeleteResponse.data?.data?.metafieldsDelete?.deletedMetafields) {
+                    if (metaId && metaId.ownerId) {
+                        numDeleted += 1;
+                    }
+                }
+                return numDeleted;
+            } else {
+                Logger.error(`deleteMetafieldsByNamespace - ${JSON.stringify(metafieldsDeleteResponse.data?.data?.metafieldsDelete?.userErrors)}`);
+                return 0;
+            }
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    /**
+   * Gets a metafield matching a product namespace and key.
+   * 
+   * @param  {number} productId
+   * @param  {string} namespace
+   * @param  {string} key
+   * @returns Promise
+   */
+    public getMetafield = async (productId: number, namespace: string, key: string): Promise<IMetafield> => {
+        return new Promise<IMetafield>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting metafield for product id -> ${productId} and namespace ${namespace} and key ${key}`);
+                const metafields = await this.getMetafields(productId);
+                let foundMetafield: IMetafield = null;
+                if (metafields && metafields.length > 0) {
+                    foundMetafield = metafields.find(m => m.namespace === namespace && m.key === key);
+                }
+                resolve(foundMetafield);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Deletes a metafields by ID for a product.
+     * 
+     * @param  {number} productId
+     * @param  {number} metafieldIds (max of 50 metafileds)
+     * @returns Promise return num of deleted metafiedls
+     */
+    public deleteMetafieldsByIds = async (productId: number, metafieldIds: number[]): Promise<number> => {
+        try {
+            Logger.info(`Deleting metafield ids ->  ${metafieldIds} for product ${productId}`);
+            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) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+}

package/shopify/product/ShopifyProductPublicationsService.ts

@@ -0,0 +1,112 @@
+import { AxiosInstance } from 'axios';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+import { Logger } from '../../Logger';
+import { AbstractService } from '../base/AbstractService';
+import InspiraShopifyError from '../errors/InspiraShopifyError';
+
+export class ShopifyProductPublicationsService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { super(); }
+
+    /**
+     * Returns a max of 15 publications
+     * 
+     * @returns {IProductPublications[]} list of publications in store.
+     */
+    public getPublications = async (): Promise<IProductPublications[]> => {
+        try {
+            Logger.info('Get product publications');
+            const query = gql`{
+                publications(first: 15) {
+                    edges {
+                        node {
+                            id
+                            name
+                            autoPublish
+                            supportsFuturePublishing
+                        }
+                    }
+                }
+            }`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query) }, { query_cost: 15 });
+            if (response && response.data && response.data.data && response.data.data.publications) {
+                const productPublicationsGraph: { node: IProductPublications }[] = response.data.data.publications.edges;
+                const productPublications: IProductPublications[] = productPublicationsGraph.map((p) => p.node);
+                return productPublications;
+            } else {
+                throw new InspiraShopifyError({ message: JSON.stringify(response.data.errors) });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+    
+    /**
+     * Publishes product to all publication channels.
+     * 
+     * @param {number} productId 
+     * @returns {IProductPublishResult}
+     */
+    public publish = async (productId: number): Promise<IProductPublishResult> => {
+        try {
+            Logger.info(`Publish product with id ${productId} to all publications`);
+            const publishQuery = gql`mutation productPublish($input: ProductPublishInput!) {
+                productPublish(input: $input) {
+                    product {
+                        id
+                    }
+                    productPublications {
+                        isPublished
+                        channel {
+                            name
+                        }
+                    }
+                    userErrors {
+                        field
+                        message
+                    }
+                }
+            }`;
+            const publications = await this.getPublications();
+            const inputParams = { id: this.getGraphProductIdFromId(productId), productPublications: publications.map(p => ({ publicationId: p.id})) };
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(publishQuery), variables: { input: inputParams } }, { query_cost: 10 });
+            if (response && response.data && response.data.data && response.data.data.productPublish) {
+                const productPublications: { isPublished: boolean; channel: { name: string;} } []= response.data.data.productPublish.productPublications;
+                
+                return { id: productId, productPublications: productPublications.filter(pp => pp.isPublished).map(pp => pp.channel) };
+            } else {
+                throw new InspiraShopifyError({ message: JSON.stringify(response.data.errors) });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+
+    /**
+     * Unpublishes product to all publication channels.
+     * 
+     * @param {number} productId 
+     * @returns {IProductUnpublishResult}
+     */
+    public unPublish = async (productId: number): Promise<IProductUnpublishResult> => {
+        try {
+            Logger.info(`Unpublish product with id ${productId} to all publications`);
+            const publishQuery = gql`mutation productUnpublish($input: ProductUnpublishInput!) {
+                productUnpublish(input: $input) {
+                    product {
+                        id
+                    }
+                    userErrors {
+                        field
+                        message
+                    }
+                }
+            }`;
+            const publications = await this.getPublications();
+            const inputParams = { id: this.getGraphProductIdFromId(productId), productPublications: publications.map(p => ({ publicationId: p.id})) };
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(publishQuery), variables: { input: inputParams } }, { query_cost: 10 });
+            if (response && response.data && response.data.data && response.data.data.productUnpublish) {
+                return { id: productId };
+            } else {
+                throw new InspiraShopifyError({ message: JSON.stringify(response.data.errors) });
+            }
+        } catch (error) { this.logErrorAndThrow(error); }
+    };
+}