@sommpicks/sommpicks-shopify 24.12.0

package/shopify/ShopifyShippingZonesService.ts

@@ -0,0 +1,37 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import { AbstractService } from './base/AbstractService';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyShippingZonesService extends AbstractService {
+
+    constructor(private axiosInstance: AxiosInstance) { 
+        super();
+    }
+
+    public getNames = async (removeDuplicates: boolean): Promise<string[]> => {
+        try {
+            Logger.info('ShopifyShippingZonesService -> getNames');
+            const response = await this.axiosInstance.get('/shipping_zones.json');
+            const shippingZones: IShippingZone[] = response.data.shipping_zones;
+            const shippingNames = [];
+            Logger.info(`ShopifyShippingZonesService -> shippingZones retrieved - ${JSON.stringify(shippingZones)}`);
+            if(shippingZones && shippingZones.length > 0) {
+                for(const sh of shippingZones) {
+                    if(sh.price_based_shipping_rates && sh.price_based_shipping_rates.length > 0){
+                        for(const psh of sh.price_based_shipping_rates) {
+                            shippingNames.push(psh.name);
+                        }
+                    }
+                    if(sh.weight_based_shipping_rates && sh.weight_based_shipping_rates.length > 0){
+                        for(const wsh of sh.weight_based_shipping_rates) {
+                            shippingNames.push(wsh.name);
+                        }
+                    }
+                }
+            }
+            return removeDuplicates ? [...new Set(shippingNames)] : shippingNames;
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+}

package/shopify/ShopifyShopService.ts

@@ -0,0 +1,101 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+
+export class ShopifyShopService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public getShopDetails = async (): Promise<IShop> => {
+        return new Promise<IShop>(async (resolve, reject) => {
+            try {
+                Logger.info('get details');
+                const response = await this.axiosInstance.get('/shop.json');
+                resolve(response.data.shop);
+            } catch (error) { Logger.error('Error in getShopDetails - ', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getShippingRates = async (): Promise<IShippingZone[]> => {
+        return new Promise<IShippingZone[]>(async (resolve, reject) => {
+            try {
+                Logger.info('getting Shipping Zones');
+                const response = await this.axiosInstance.get('/shipping_zones.json');
+                resolve(response.data.shipping_zones);
+            } catch (error) { Logger.error('Error in getShippingRates - ', error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    /**
+     * Get SHOP metafield
+     *
+     * @returns Promise
+     */
+    public getMetafield = async (namespace: string, key: string): Promise<{id: string; metafield: { value: string; key: string; type: string; namespace: string; }}> => {
+        try {
+            Logger.info('Getting Shop Metafield');
+            const query = gql `query { shop {
+                    id
+                    metafield(namespace: "${namespace}", key: "${key}") {
+                        value
+                        key
+                        type
+                        namespace
+                        id
+                    }
+                }
+            }`;
+            const response = await this.axiosInstance.post('/graphql.json', { query: print(query), 
+                variables: {} }, { query_cost: 10 });
+
+            if(response && response.data && response.data.data && response.data.data.shop && response.data.data.shop.id ){
+                return { id: response.data.data.shop.id, metafield: response.data.data.shop.metafield };
+            } else {
+                Logger.error(`Get SHOP metafield. Error is ${JSON.stringify(response.data.errors)}. All data is ${JSON.stringify(response.data)}` );
+            }
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+  
+    /**
+     * Sets SHOP metafield 
+     * 
+     * @param  {number} shopId
+     * @param  {string} namespace
+     * @param  {string} key
+     * @param  {string} value
+     * 
+     * @returns Promise
+     */
+    public setMetafield = async (shopId: number, namespace: string, key: string, value: string): Promise<{shopId: number;}> => {
+        try { 
+            Logger.info(`Set SHOP metafield for ${shopId}, namespace: ${namespace} and key: ${key} with val ${value}`);
+            const metafieldQuery = gql `mutation CreateShopMetafield($configurationValue: String!) {
+                metafieldsSet(metafields: [
+                {
+                    ownerId: "gid://shopify/Shop/${shopId}"
+                    namespace: "${namespace}"
+                    key: "${key}"
+                    value: $configurationValue
+                    type: "json"
+                }
+                ]) {
+                    metafields {
+                        id
+                    }
+                    userErrors {
+                        message
+                    }
+                }
+            }`;
+                
+            const metafieldResponse = await this.axiosInstance.post('/graphql.json', { query: print(metafieldQuery), 
+                variables: { configurationValue: value }}, { query_cost: 803 });
+
+            Logger.info(`Shop Metafield response ${JSON.stringify(metafieldResponse.data)}`);
+            return { shopId: shopId };
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+}

package/shopify/ShopifyTemplateService.ts

@@ -0,0 +1,30 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyTemplateService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public get = async (themeId: number, template: string): Promise<ITemplate> => {
+        return new Promise<ITemplate>(async (resolve, reject) => {
+            try {
+                Logger.info(`Getting template ${template} from theme ${themeId}`);
+                const response = await this.axiosInstance.get(`/themes/${themeId}/assets.json?asset[key]=${template}&theme_id=${themeId}`);
+                resolve(response.data.asset);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public put = async (themeId: number, template: string, value: string): Promise<ITemplate> => {
+        return new Promise<ITemplate>(async (resolve, reject) => {
+            try {
+                Logger.info(`Changing template ${template} from theme ${themeId}`);
+                const changeTemplateRequest = {key: template, value: value};
+                const response = await this.axiosInstance.put(`/themes/${themeId}/assets.json`, {asset: changeTemplateRequest});
+                resolve(response.data.asset);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}

package/shopify/ShopifyThemeService.ts

@@ -0,0 +1,33 @@
+import { AxiosInstance } from 'axios';
+import { Logger } from '../Logger';
+import ErrorHelper from './base/ErrorHelper';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyThemeService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public getAll = async (): Promise<ITheme[]> => {
+        return new Promise<ITheme[]>(async (resolve, reject) => {
+            try {
+                Logger.info('Getting all themes');
+                const response = await this.axiosInstance.get('/themes.json?limit=250');
+                resolve(response.data.themes);
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+
+    public getMainTheme = async (): Promise<ITheme> => {
+        return new Promise<ITheme>(async (resolve, reject) => {
+            try {
+                Logger.info('Getting main themes');
+                const themes = await this.getAll();
+                if (themes && themes.length) {
+                    resolve(themes.find(theme => theme.role === 'main'));
+                } else {
+                    resolve(null);
+                }
+            } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); reject(new InspiraShopifyError(error)); }
+        });
+    };
+}

package/shopify/ShopifyUtils.ts

@@ -0,0 +1,56 @@
+import axiosRetry from 'axios-retry';
+import AxiosRateLimit from '@inspiradigital/inspira-shopify-rate-limit';
+import axios, { AxiosInstance } from 'axios';
+import { setupCache, buildMemoryStorage } from 'axios-cache-interceptor';
+import APIVersion from './base/APIVersion';
+
+export interface AxiosInstanceExtended extends AxiosInstance {
+    getQueueInfo: () => { request_within_last_second: number; apiQueue: number; graphQueue: number; apiProcessed: number; graphProcessed: number;};
+}
+
+export class ShopifyUtils {
+
+    public static getAxiosInstance = (shop: string, token: string, api_key: string, password: string, options: IRest_Options): AxiosInstanceExtended => {
+        if (!options) { options.enableCache = false; options.timeout = 30000; options.retries = 3; options.logger = null; options.max_requests_per_sec = 2; }
+        if (!options.timeout) { options.timeout = 30000; }
+        if (!options.retries) { options.retries = 5; }
+        if (!options.retries) { options.retries = 5; }
+        if (!options.enableCache) { options.enableCache = false; }
+        if (!options.max_requests_per_sec) { options.max_requests_per_sec = 2; }
+        let client;
+        if (token) {
+            client = axios.create({
+                baseURL: `https://${shop}/admin/${APIVersion.API_URL}`,
+                timeout: options.timeout,
+                headers: {
+                    'X-Shopify-Access-Token': token,
+                    'Content-Type': 'application/json;charset=UTF-8'
+                }
+            });
+        } else if (api_key && password) {
+            client = axios.create({
+                baseURL: `https://${api_key}:${password}@${shop}/admin/${APIVersion.API_URL}`,
+                timeout: options.timeout,
+                headers: { 'Content-Type': 'application/json;charset=UTF-8' }
+            });
+        } else {
+            throw 'No acces token defined AND no private app key and password set so it is not possible to build the admin shop url';
+        }
+        (axiosRetry as any)(client, {
+            retries: options.retries,
+            retryDelay: (retryCount: number) => {
+                if (options.logger && retryCount === options.retries) options.logger.error(`Retry ${retryCount} ...`);
+                return retryCount * (retryCount > 3 ? 2000 : 500);
+            },
+            shouldResetTimeout: true,
+            retryCondition: (error: any) => {
+                return (axiosRetry as any).isNetworkOrIdempotentRequestError(error) || (error.response.status >= 500 && error.response.status <= 599) || (error.response && error.response.status === 429);
+            }
+        });
+        const axiosRateLimit = new AxiosRateLimit(client, options.max_requests_per_sec, 50);
+        if(options.enableCache) {
+            client = setupCache(axiosRateLimit.getInstance(), { methods: ['get'], storage: buildMemoryStorage(true, options.cacheTimeInMiliseconds) });
+        }
+        return options.enableCache ? client : axiosRateLimit.getInstance();
+    };
+}

package/shopify/ShopifyWebhookService.ts

@@ -0,0 +1,110 @@
+import { Logger } from '../Logger';
+import { AxiosInstance } from 'axios';
+import ErrorHelper from './base/ErrorHelper';
+import APIVersion from './base/APIVersion';
+import InspiraShopifyError from './errors/InspiraShopifyError';
+
+export class ShopifyWebhookService {
+
+    constructor(private axiosInstance: AxiosInstance) { }
+
+    public create = async (webhook: IWeebHook): Promise<IWeebHook> => {
+        try {
+            Logger.info('create webhook', webhook);
+            const response = await this.axiosInstance.post('/webhooks.json', { webhook: webhook });
+            return response.data.webhook;
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    public deleteAll = async (): Promise<void> => {
+        try {
+            Logger.info('delete All webhooks');
+            const webhooks = await this.getAll();
+            for (const webhook of webhooks) {
+                await this.axiosInstance.delete(`/webhooks/${webhook.id}.json`);
+            }
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    public delete = async (id: number): Promise<void> => {
+        try {
+            Logger.info(`delete webhook with ID ${id}`);
+            await this.axiosInstance.delete(`/webhooks/${id}.json`);
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    public deleteByTopic = async (topic: webhookTopic): Promise<void> => {
+        try {
+            const currentWebhooks: IWeebHook[] = await this.getAll();
+            for(const webhookInLoop of currentWebhooks) {
+                if(webhookInLoop.topic === topic) {
+                    await this.delete(webhookInLoop.id);
+                }
+            }
+        } catch (error) { Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    public getAll = async (): Promise<IWeebHook[]> => {
+        try {
+            Logger.info('get All webhooks');
+            const response = await this.axiosInstance.get('/webhooks.json');
+            return response.data.webhooks;
+        } catch (error) {Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    
+    /**
+     * Rebuilds all webhooks with the current API Version. @link APIVersion
+     * 
+     * @returns Promise
+     */
+    public updateWebhooksAPI = async (): Promise<void> => {
+        try {
+            const webhooks: IWeebHook[] = await this.getAll();
+            for(const webhook of webhooks) {
+                if(webhook.api_version !== APIVersion.VERSION) {
+                    const newWebhook: IWeebHook = { topic: webhook.topic, format: webhook.format, address: webhook.address };
+                    await this.delete(webhook.id);
+                    await this.create(newWebhook);
+                } else {
+                    Logger.info(`Webhooks has the current API version ${APIVersion.VERSION}`);
+                }
+            }
+        } catch (error) {Logger.error('Error rebuilding webhooks wit the correct API', error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error); }
+    };
+
+    /**
+     * It creates all to webhooks for the store only when they same topic does not exists.
+     * It does not check if the base URL has changed so it will not work when you are trying to create the same topic pointing to different URLs.
+     * 
+     * @param {webhookTopic[]} webhookTopics
+     * @param {string} baseUrl URL of the APP
+     */
+    public createStoreWebHooks = async (baseUrl: string, webhookTopics: webhookTopic[]): Promise<void> => {
+        try {
+            Logger.info(`Creating webhooks ${webhookTopics}`);
+            const webhooks = await this.getAll();
+            let webFailures = 0;
+            let errorMsgs = '';
+            for(const topic of webhookTopics) {
+                try {
+                    await this.createStoreWebhook(baseUrl, webhooks, topic);
+                } catch(error) {
+                    webFailures += 1;
+                    errorMsgs = `${errorMsgs}${error.message} `;
+                }
+            }
+            if(webFailures > 0) {
+                throw new InspiraShopifyError({ message: `${webFailures} webhooks have not been created with errors ${errorMsgs.trim()}` });
+            }
+        } catch (error) { Logger.error('Error while creating webhooks, they might be already created'); throw new InspiraShopifyError(error); }
+    };
+
+    private createStoreWebhook = async (baseUrl: string, webhooks: IWeebHook[], topic: webhookTopic): Promise<void> => {
+        if (!webhooks.find( (webhook) => webhook.topic === topic)) {
+            await this.create({ format: 'json', topic: topic, address: `${baseUrl}/${topic}` });
+        } else {
+            Logger.info(`Webhook ${topic} already exists`);
+        }
+    };
+}

package/shopify/base/APIVersion.ts

@@ -0,0 +1,4 @@
+export default class APIVersion {
+    public static VERSION = '2025-04';
+    public static API_URL = `api/${APIVersion.VERSION}`; 
+}

package/shopify/base/AbstractService.ts

@@ -0,0 +1,152 @@
+import { Logger } from '../../Logger';
+import ErrorHelper from './ErrorHelper';
+import InspiraShopifyError from '../errors/InspiraShopifyError';
+
+export class AbstractService {
+
+    constructor() { }
+    
+    public getIdFromGraphId = (id: string): number => {
+        try {
+            const idCandidate = id.split('/').slice(-1)[0].split('?')[0];
+            return parseInt(idCandidate, 10);
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphProductIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/Product/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphProductVariantIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/ProductVariant/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphLocationIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/Location/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphOrderIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/Order/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphAutomaticDiscountIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/DiscountAutomaticNode/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphMetafieldIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/Metafield/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphDeliveryCustomisationIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/DeliveryCustomization/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphCartTransformIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/CartTransform/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphInventoryItemIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/InventoryItem/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphProductDiscountIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/DiscountAutomaticNode/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getGraphCollectionIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/Collection/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getInventoryItemIdFromId = (id: number): string => {
+        try {
+            return `gid://shopify/InventoryItem/${id}`.trim();
+        } catch(e) {
+            return null;
+        }
+    };
+
+    public getMetafieldType = (metafieldValueType: string, value: string): IMetafieldType => {
+        if(metafieldValueType === 'string') {
+            if(value && value.indexOf('\n') > -1) {
+                return 'multi_line_text_field';
+            } else {
+                return 'single_line_text_field';
+            }
+        } else if( metafieldValueType === 'integer') {
+            return 'number_decimal';
+        } else if (metafieldValueType === 'json_string') {
+            return 'json';
+        } else {
+            return metafieldValueType as IMetafieldType;
+        }
+    };
+
+    public sliceIntoChunks =  <T extends any[]>(arr: T, chunkSize: number): T[] => {
+        const chunks = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            const chunk = arr.slice(i, i + chunkSize);
+            chunks.push(chunk);
+        }
+        return chunks;
+    };
+
+    public escapeQuotes = (value: string): string => {
+        if(value && value.replace) {
+            return  value.replace(/\\([\s\S])|(")/g,'\\$1$2');
+        } else if(value && !value.replace) {
+            return value;
+        } else {
+            return '';
+        }
+    };
+
+    public logErrorAndThrow = (error: any): void => {
+        Logger.error(error, ErrorHelper.getErrorFromResponse(error)); throw new InspiraShopifyError(error);
+    };
+}

package/shopify/base/ErrorHelper.ts

@@ -0,0 +1,24 @@
+export default class ErrorHelper {
+
+    public static getErrorFromResponse = (error: any): any => {
+        let data = '';
+        if (error && error.response && error.response.data && error.response.data.errors) {
+            if(typeof error.response.data.errors === 'string') {
+                data = error.response.data.errors;
+            } else {
+                for(const key in error.response.data.errors) {
+                    data = `${data}, ${key}: ${error.response.data.errors[key]};`;
+                }
+            }
+        } else if (error && error.response && error.response.statusText) {
+            data = `${error.response.status} : ${error.response.statusText}`;
+        } else if (error && error.response) {
+            data = error.response;
+        } else if (error && error.message) {
+            data = error.message;
+        } else {
+            data = error;
+        }
+        return data;
+    };
+}

package/shopify/errors/InspiraShopifyCustomError.ts

@@ -0,0 +1,7 @@
+export default class InspiraShopifyCustomError extends Error {
+    constructor(msg: string) {
+        super(msg);
+        this.name = 'InspiraShopifyError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/shopify/errors/InspiraShopifyError.ts

@@ -0,0 +1,15 @@
+import ErrorHelper from '../base/ErrorHelper';
+
+export default class InspiraShopifyError extends Error {
+    constructor(error: Error | { message: string; }) {
+        const message = ErrorHelper.getErrorFromResponse(error);
+        try {
+            const stringifiedMsg = JSON.stringify(message);
+            super(stringifiedMsg);
+        } catch(e) {
+            super();
+        }
+        this.name = 'InspiraShopifyError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/shopify/errors/InspiraShopifyUnableToReserveInventoryError.ts

@@ -0,0 +1,7 @@
+export default class InspiraShopifyUnableToReserveInventoryError extends Error {
+    constructor(msg: string) {
+        super(msg);
+        this.name = 'InspiraShopifyUnableToReserveInventoryError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}