@sommpicks/sommpicks-shopify 24.12.0

package/shopify/router/ShopifyRouter.ts

@@ -0,0 +1,85 @@
+import * as express from 'express';
+import * as querystring from 'querystring';
+import { CryptoService } from './services/CryptoService';
+import { OauthService } from './services/OauthService';
+import { Request, Response } from 'express-serve-static-core';
+import { Logger } from '../../Logger';
+
+const router = express.Router();
+
+export class ShopifyRouter {
+
+    private cryptoService: CryptoService;
+
+    constructor( private shop_secret: string, private shop_key: string, private appBaseUrl: string, private endpointUri: string, private getScopes: (shop: string) => string | Promise<string>, private callback: (accessToken: string, shop: string, host: string, expresResponse: Response, secFetchDest: boolean, error: any) => void) {
+        this.cryptoService = new CryptoService();
+    }
+
+    public buildRoutes(): express.Router {
+        router.get('/', async (req,res,next) => {
+            const scopes = await this.getScopes(req.query.shop as string);
+            res.locals.scopes = scopes;
+            next();
+        }, this.installRoute);
+        router.get('/callback', this.callBackRoute);
+        return router;
+    }
+
+    public callBackRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const shop = expresRequest.query.shop as string;
+        const hmac = expresRequest.query.hmac as string;
+        const code = expresRequest.query.code as string;
+        const host = expresRequest.query.host as string;
+        Logger.info(`ShopifyRouter - callBackRoute From shopify ${code}`);
+        if (shop && hmac && code) {
+            const map = Object.assign({}, expresRequest.query);
+            delete map['signature'];
+            delete map['hmac'];
+            const secFetchDest = req.headers['sec-fetch-dest'];
+            const message = querystring.stringify(map as any);
+
+            const hashEquals = this.cryptoService.checkHash(this.cryptoService.generateHash(message, this.shop_secret), hmac);
+            if (!hashEquals) { expresResponse.status(401).send('HMAC validation failed'); return; }
+            Logger.info(`getOathToken From shopify ${code}`);
+            OauthService.getOathToken(shop, this.shop_key, this.shop_secret, code,
+                (accessToken: string) => {
+                    this.callback(accessToken, shop, host, expresResponse, secFetchDest === 'iframe', null);
+                },
+                (errorStatus: string, error: string) => {
+                    Logger.error(`Error while getOathToken - status: ${errorStatus} and message: ${error}`);
+                    this.callback(null, shop, host, expresResponse, secFetchDest === 'iframe', { error: error, errorStatus: errorStatus });
+                });
+        } else {
+            expresResponse.status(400).send('Required parameters missing');
+        }
+    };
+
+    public installRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const scopes = res.locals.scopes;
+        const shop = expresRequest.query.shop as string;
+        const host = expresRequest.query.host;
+        if (shop) {
+            if(!expresRequest.query.session) {
+                expresResponse.render('session_expire', { redirectUrl: this.installUrl(shop, scopes) });
+            } else {
+                expresResponse.redirect(`${this.appBaseUrl}/billing/created?host=${host}&shop=${shop}&status=already_accepted`);
+            }
+        } else {
+            return expresResponse.status(400).send('Missing shop parameter.');
+        }
+    };
+
+    private installUrl(shop: string, scopes: string): string {
+        return `https://${shop}/admin/oauth/authorize?client_id=${this.shop_key}&scope=${scopes}&redirect_uri=${this.redirectUri()}`;
+    }
+
+    private redirectUri(): string {
+        return `${this.appBaseUrl}${this.endpointUri}/callback`;
+    }
+}
+
+export default ShopifyRouter;

package/shopify/router/ShopifyRouterBis.ts

@@ -0,0 +1,85 @@
+import * as express from 'express';
+import * as querystring from 'querystring';
+import { CryptoService } from './services/CryptoService';
+import { OauthService } from './services/OauthService';
+import { Request, Response } from 'express-serve-static-core';
+import { Logger } from '../../Logger';
+
+const router = express.Router();
+
+export class ShopifyRouterBis {
+
+    private cryptoService: CryptoService;
+
+    constructor( private shop_secret: string, private shop_key: string, private appBaseUrl: string, private endpointUri: string, private getScopes: (shop: string) => string | Promise<string>, private callback: (accessToken: string, shop: string, host: string, expresResponse: Response, secFetchDest: boolean, error: any) => void) {
+        this.cryptoService = new CryptoService();
+    }
+
+    public buildRoutes(): express.Router {
+        router.get('/', async (req,res,next) => {
+            const scopes = await this.getScopes(req.query.shop as string);
+            res.locals.scopes = scopes;
+            next();
+        }, this.installRoute );
+        router.get('/callback', this.callBackRoute);
+        return router;
+    }
+
+    public callBackRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const shop = expresRequest.query.shop as string;
+        const hmac = expresRequest.query.hmac as string;
+        const code = expresRequest.query.code as string;
+        const host = expresRequest.query.host as string;
+        Logger.info(`ShopifyRouter - callBackRoute From shopify ${code}`);
+        if (shop && hmac && code) {
+            const map = Object.assign({}, expresRequest.query);
+            delete map['signature'];
+            delete map['hmac'];
+            const secFetchDest = req.headers['sec-fetch-dest'];
+            const message = querystring.stringify(map as any);
+
+            const hashEquals = this.cryptoService.checkHash(this.cryptoService.generateHash(message, this.shop_secret), hmac);
+            if (!hashEquals) { expresResponse.status(401).send('HMAC validation failed'); return; }
+            Logger.info(`getOathToken From shopify ${code}`);
+            OauthService.getOathToken(shop, this.shop_key, this.shop_secret, code,
+                (accessToken: string) => {
+                    this.callback(accessToken, shop, host, expresResponse, secFetchDest === 'iframe', null);
+                },
+                (errorStatus: string, error: string) => {
+                    Logger.error(`Error while getOathToken - status: ${errorStatus} and message: ${error}`);
+                    this.callback(null, shop, host, expresResponse, secFetchDest === 'iframe', { error: error, errorStatus: errorStatus });
+                });
+        } else {
+            expresResponse.status(400).send('Required parameters missing');
+        }
+    };
+
+    public installRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const scopes = res.locals.scopes;
+        const shop = expresRequest.query.shop as string;
+        const host = expresRequest.query.host;
+        if (shop) {
+            if(!expresRequest.query.session) {
+                expresResponse.render('session_expire', { redirectUrl: this.installUrl(shop, scopes) });
+            } else {
+                expresResponse.redirect(`${this.appBaseUrl}/billing/created?host=${host}&shop=${shop}&status=already_accepted`);
+            }
+        } else {
+            return expresResponse.status(400).send('Missing shop parameter.');
+        }
+    };
+
+    private installUrl(shop: string, scopes: string): string {
+        return `https://${shop}/admin/oauth/authorize?client_id=${this.shop_key}&scope=${scopes}&redirect_uri=${this.redirectUri()}`;
+    }
+
+    private redirectUri(): string {
+        return `${this.appBaseUrl}${this.endpointUri}/callback`;
+    }
+}
+
+export default ShopifyRouterBis;

package/shopify/router/ShopifyRouterBisBis.ts

@@ -0,0 +1,85 @@
+import * as express from 'express';
+import * as querystring from 'querystring';
+import { CryptoService } from './services/CryptoService';
+import { OauthService } from './services/OauthService';
+import { Request, Response } from 'express-serve-static-core';
+import { Logger } from '../../Logger';
+
+const router = express.Router();
+
+export class ShopifyRouterBisBis {
+
+    private cryptoService: CryptoService;
+
+    constructor( private shop_secret: string, private shop_key: string, private appBaseUrl: string, private endpointUri: string, private getScopes: (shop: string) => string | Promise<string>, private callback: (accessToken: string, shop: string, host: string, expresResponse: Response, secFetchDest: boolean, error: any) => void) {
+        this.cryptoService = new CryptoService();
+    }
+
+    public buildRoutes(): express.Router {
+        router.get('/', async (req,res,next) => {
+            const scopes = await this.getScopes(req.query.shop as string);
+            res.locals.scopes = scopes;
+            next();
+        }, this.installRoute );
+        router.get('/callback', this.callBackRoute);
+        return router;
+    }
+
+    public callBackRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const shop = expresRequest.query.shop as string;
+        const hmac = expresRequest.query.hmac as string;
+        const code = expresRequest.query.code as string;
+        const host = expresRequest.query.host as string;
+        Logger.info(`ShopifyRouter - callBackRoute From shopify ${code}`);
+        if (shop && hmac && code) {
+            const map = Object.assign({}, expresRequest.query);
+            delete map['signature'];
+            delete map['hmac'];
+            const secFetchDest = req.headers['sec-fetch-dest'];
+            const message = querystring.stringify(map as any);
+
+            const hashEquals = this.cryptoService.checkHash(this.cryptoService.generateHash(message, this.shop_secret), hmac);
+            if (!hashEquals) { expresResponse.status(401).send('HMAC validation failed'); return; }
+            Logger.info(`getOathToken From shopify ${code}`);
+            OauthService.getOathToken(shop, this.shop_key, this.shop_secret, code,
+                (accessToken: string) => {
+                    this.callback(accessToken, shop, host, expresResponse, secFetchDest === 'iframe', null);
+                },
+                (errorStatus: string, error: string) => {
+                    Logger.error(`Error while getOathToken - status: ${errorStatus} and message: ${error}`);
+                    this.callback(null, shop, host, expresResponse, secFetchDest === 'iframe', { error: error, errorStatus: errorStatus });
+                });
+        } else {
+            expresResponse.status(400).send('Required parameters missing');
+        }
+    };
+
+    public installRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const scopes = res.locals.scopes;
+        const shop = expresRequest.query.shop as string;
+        const host = expresRequest.query.host;
+        if (shop) {
+            if(!expresRequest.query.session) {
+                expresResponse.render('session_expire', { redirectUrl: this.installUrl(shop, scopes) });
+            } else {
+                expresResponse.redirect(`${this.appBaseUrl}/billing/created?host=${host}&shop=${shop}&status=already_accepted`);
+            }
+        } else {
+            return expresResponse.status(400).send('Missing shop parameter.');
+        }
+    };
+
+    private installUrl(shop: string, scopes: string): string {
+        return `https://${shop}/admin/oauth/authorize?client_id=${this.shop_key}&scope=${scopes}&redirect_uri=${this.redirectUri()}`;
+    }
+
+    private redirectUri(): string {
+        return `${this.appBaseUrl}${this.endpointUri}/callback`;
+    }
+}
+
+export default ShopifyRouterBisBis;

package/shopify/router/ShopifyRouterBisBisBis.ts

@@ -0,0 +1,85 @@
+import * as express from 'express';
+import * as querystring from 'querystring';
+import { CryptoService } from './services/CryptoService';
+import { OauthService } from './services/OauthService';
+import { Request, Response } from 'express-serve-static-core';
+import { Logger } from '../../Logger';
+
+const router = express.Router();
+
+export class ShopifyRouterBisBisBis {
+
+    private cryptoService: CryptoService;
+
+    constructor( private shop_secret: string, private shop_key: string, private appBaseUrl: string, private endpointUri: string, private getScopes: (shop: string) => string | Promise<string>, private callback: (accessToken: string, shop: string, host: string, expresResponse: Response, secFetchDest: boolean, error: any) => void) {
+        this.cryptoService = new CryptoService();
+    }
+
+    public buildRoutes(): express.Router {
+        router.get('/', async (req,res,next) => {
+            const scopes = await this.getScopes(req.query.shop as string);
+            res.locals.scopes = scopes;
+            next();
+        }, this.installRoute );
+        router.get('/callback', this.callBackRoute);
+        return router;
+    }
+
+    public callBackRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const shop = expresRequest.query.shop as string;
+        const hmac = expresRequest.query.hmac as string;
+        const code = expresRequest.query.code as string;
+        const host = expresRequest.query.host as string;
+        Logger.info(`ShopifyRouter - callBackRoute From shopify ${code}`);
+        if (shop && hmac && code) {
+            const map = Object.assign({}, expresRequest.query);
+            delete map['signature'];
+            delete map['hmac'];
+            const secFetchDest = req.headers['sec-fetch-dest'];
+            const message = querystring.stringify(map as any);
+
+            const hashEquals = this.cryptoService.checkHash(this.cryptoService.generateHash(message, this.shop_secret), hmac);
+            if (!hashEquals) { expresResponse.status(401).send('HMAC validation failed'); return; }
+            Logger.info(`getOathToken From shopify ${code}`);
+            OauthService.getOathToken(shop, this.shop_key, this.shop_secret, code,
+                (accessToken: string) => {
+                    this.callback(accessToken, shop, host, expresResponse, secFetchDest === 'iframe', null);
+                },
+                (errorStatus: string, error: string) => {
+                    Logger.error(`Error while getOathToken - status: ${errorStatus} and message: ${error}`);
+                    this.callback(null, shop, host, expresResponse, secFetchDest === 'iframe', { error: error, errorStatus: errorStatus });
+                });
+        } else {
+            expresResponse.status(400).send('Required parameters missing');
+        }
+    };
+
+    public installRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const scopes = res.locals.scopes;
+        const shop = expresRequest.query.shop as string;
+        const host = expresRequest.query.host;
+        if (shop) {
+            if(!expresRequest.query.session) {
+                expresResponse.render('session_expire', { redirectUrl: this.installUrl(shop, scopes) });
+            } else {
+                expresResponse.redirect(`${this.appBaseUrl}/billing/created?host=${host}&shop=${shop}&status=already_accepted`);
+            }
+        } else {
+            return expresResponse.status(400).send('Missing shop parameter.');
+        }
+    };
+
+    private installUrl(shop: string, scopes: string): string {
+        return `https://${shop}/admin/oauth/authorize?client_id=${this.shop_key}&scope=${scopes}&redirect_uri=${this.redirectUri()}`;
+    }
+
+    private redirectUri(): string {
+        return `${this.appBaseUrl}${this.endpointUri}/callback`;
+    }
+}
+
+export default ShopifyRouterBisBisBis;

package/shopify/router/ShopifyRouterBisBisBisBis.ts

@@ -0,0 +1,85 @@
+import * as express from 'express';
+import * as querystring from 'querystring';
+import { CryptoService } from './services/CryptoService';
+import { OauthService } from './services/OauthService';
+import { Request, Response } from 'express-serve-static-core';
+import { Logger } from '../../Logger';
+
+const router = express.Router();
+
+export class ShopifyRouterBisBisBisBis {
+
+    private cryptoService: CryptoService;
+
+    constructor( private shop_secret: string, private shop_key: string, private appBaseUrl: string, private endpointUri: string, private getScopes: (shop: string) => string | Promise<string>, private callback: (accessToken: string, shop: string, host: string, expresResponse: Response, secFetchDest: boolean, error: any) => void) {
+        this.cryptoService = new CryptoService();
+    }
+
+    public buildRoutes(): express.Router {
+        router.get('/', async (req,res,next) => {
+            const scopes = await this.getScopes(req.query.shop as string);
+            res.locals.scopes = scopes;
+            next();
+        }, this.installRoute );
+        router.get('/callback', this.callBackRoute);
+        return router;
+    }
+
+    public callBackRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const shop = expresRequest.query.shop as string;
+        const hmac = expresRequest.query.hmac as string;
+        const code = expresRequest.query.code as string;
+        const host = expresRequest.query.host as string;
+        Logger.info(`ShopifyRouter - callBackRoute From shopify ${code}`);
+        if (shop && hmac && code) {
+            const map = Object.assign({}, expresRequest.query);
+            delete map['signature'];
+            delete map['hmac'];
+            const secFetchDest = req.headers['sec-fetch-dest'];
+            const message = querystring.stringify(map as any);
+
+            const hashEquals = this.cryptoService.checkHash(this.cryptoService.generateHash(message, this.shop_secret), hmac);
+            if (!hashEquals) { expresResponse.status(401).send('HMAC validation failed'); return; }
+            Logger.info(`getOathToken From shopify ${code}`);
+            OauthService.getOathToken(shop, this.shop_key, this.shop_secret, code,
+                (accessToken: string) => {
+                    this.callback(accessToken, shop, host, expresResponse, secFetchDest === 'iframe', null);
+                },
+                (errorStatus: string, error: string) => {
+                    Logger.error(`Error while getOathToken - status: ${errorStatus} and message: ${error}`);
+                    this.callback(null, shop, host, expresResponse, secFetchDest === 'iframe', { error: error, errorStatus: errorStatus });
+                });
+        } else {
+            expresResponse.status(400).send('Required parameters missing');
+        }
+    };
+
+    public installRoute = (req: any, res: any) => {
+        const expresRequest = req as Request;
+        const expresResponse = res as Response;
+        const scopes = res.locals.scopes;
+        const shop = expresRequest.query.shop as string;
+        const host = expresRequest.query.host;
+        if (shop) {
+            if(!expresRequest.query.session) {
+                expresResponse.render('session_expire', { redirectUrl: this.installUrl(shop, scopes) });
+            } else {
+                expresResponse.redirect(`${this.appBaseUrl}/billing/created?host=${host}&shop=${shop}&status=already_accepted`);
+            }
+        } else {
+            return expresResponse.status(400).send('Missing shop parameter.');
+        }
+    };
+
+    private installUrl(shop: string, scopes: string): string {
+        return `https://${shop}/admin/oauth/authorize?client_id=${this.shop_key}&scope=${scopes}&redirect_uri=${this.redirectUri()}`;
+    }
+
+    private redirectUri(): string {
+        return `${this.appBaseUrl}${this.endpointUri}/callback`;
+    }
+}
+
+export default ShopifyRouterBisBisBisBis;

package/shopify/router/WebhookSkipMiddleware.ts

@@ -0,0 +1,73 @@
+import { Request, Response } from 'express-serve-static-core';
+
+export default class WebhookSkipMiddleware {
+
+    private static productIdsToSkip: number[] = [];
+    private static inventoryIdsToSkip: number[] = [];
+    public static awaitTime = 30000;
+
+    public static clearProductList = () => {
+        WebhookSkipMiddleware.productIdsToSkip = [];
+    };
+
+    public static addProductId = (id: number) => {
+        const index = WebhookSkipMiddleware.productIdsToSkip.findIndex((i) => id === i);
+        if(index === -1) {
+            WebhookSkipMiddleware.productIdsToSkip.push(id);
+            setTimeout(() => WebhookSkipMiddleware.removeProductId(id), WebhookSkipMiddleware.awaitTime);
+        }
+    };
+
+    public static removeProductId = (id: number) => {
+        const index = WebhookSkipMiddleware.productIdsToSkip.findIndex((i) => id === i);
+        WebhookSkipMiddleware.productIdsToSkip.splice(index, 1);
+    };
+    
+    public static clearInventoryList = () => {
+        WebhookSkipMiddleware.inventoryIdsToSkip = [];
+    };
+
+    public static addInventoryId = (id: number) => {
+        const index = WebhookSkipMiddleware.inventoryIdsToSkip.findIndex((i) => id === i);
+        if(index === -1) {
+            WebhookSkipMiddleware.inventoryIdsToSkip.push(id);
+            setTimeout(() => WebhookSkipMiddleware.removeInventoryId(id), WebhookSkipMiddleware.awaitTime);
+        }
+    };
+
+    public static removeInventoryId = (id: number) => {
+        const index = WebhookSkipMiddleware.inventoryIdsToSkip.findIndex((i) => id === i);
+        WebhookSkipMiddleware.inventoryIdsToSkip.splice(index, 1);
+    };
+    
+    /**
+     * The id of the element to skip must be in req.body.id for that to work.
+     * 
+     * @param  {Request} req
+     * @param  {Response} res
+     * @param  {()=>void} next
+     */
+    public static productSkipMiddleware = (req: Request, res: Response, next: () => void ) => {
+        if(WebhookSkipMiddleware.productIdsToSkip.includes(req.body.id)) {
+            res.sendStatus(200);
+        } else {
+            next();
+        }
+    };
+    
+    /**
+     * The id of the element to skip must be in req.body.id for that to work.
+     * 
+     * @param  {Request} req
+     * @param  {Response} res
+     * @param  {()=>void} next
+     */
+    public static inventorySkipMiddleware = (req: Request, res: Response, next: () => void ) => {
+        if(WebhookSkipMiddleware.inventoryIdsToSkip.includes(req.body.id)) {
+            res.sendStatus(200);
+        } else {
+            next();
+        }
+    };
+
+}

package/shopify/router/services/CryptoService.ts

@@ -0,0 +1,26 @@
+import * as crypto from 'crypto';
+
+export class CryptoService {
+
+    public generateHash(message: string | Buffer, secret: string): Buffer {
+        return Buffer.from(
+            crypto.createHmac('sha256', secret).update(message).digest('hex'),
+            'utf-8'
+        );
+    }
+
+    public generateHashBase64(message: string | Buffer, secret: string): string {
+        return crypto.createHmac('sha256', secret).update(message).digest('base64');
+    }
+
+    public checkHash(generatedHash: Buffer, hmacToCheck: string): boolean {
+        let hashEquals = false;
+        const providedHmac = Buffer.from(hmacToCheck, 'utf-8');
+        try {
+            hashEquals = crypto.timingSafeEqual(generatedHash, providedHmac);
+        } catch (e) {
+            hashEquals = false;
+        }
+        return hashEquals;
+    }
+}

package/shopify/router/services/HmacValidator.ts

@@ -0,0 +1,36 @@
+import * as express from 'express';
+import { CryptoService } from './CryptoService';
+import { Request } from 'express-serve-static-core';
+import { IncomingMessage, ServerResponse } from 'http';
+
+export default class HmacValidator {
+
+    private static cryptoService = new CryptoService();
+
+    public static jsonWebhookParser: any = express.json({
+        type: '*/*',
+        limit: '50mb',
+        verify: function (req: IncomingMessage, res: ServerResponse, buf): void {
+            (req as any).rawBody = buf;
+        }
+    });
+
+    public static getHmac = (req: Request): string => {
+        return (req.headers['x-shopify-hmac-sha256'] as string);
+    };
+
+    public static checkHmac = async (req: Request, signature: string): Promise<boolean> => {
+        return new Promise<boolean>(async (resolve, reject) => {
+            try {
+                const hmac = HmacValidator.getHmac(req);
+                if(!hmac) {
+                    resolve(false);
+                } else {
+                    const generated_hmac = HmacValidator.cryptoService.generateHashBase64((req as any).rawBody, signature);
+                    const hashEquals = HmacValidator.cryptoService.checkHash(Buffer.from(generated_hmac, 'utf8'), hmac);
+                    if (!hashEquals) { resolve(false); } else { resolve(true); }
+                }
+            } catch(err) { reject(Error(err)); }
+        });
+    };
+}

package/shopify/router/services/OauthService.ts

@@ -0,0 +1,17 @@
+import axios from 'axios';
+import { Logger } from '../../../Logger';
+
+export class OauthService {
+    public static getOathToken(shop: string, apiKey: string, sercret: string, code: string, successCallback: (token: string) => void, failureCalback: (code: string, error: string, ) => void){
+        const accessTokenPayload = { client_id: apiKey, client_secret: sercret, code: code };
+        Logger.info(`getOathToken - accessTokenPayload: ${JSON.stringify(accessTokenPayload)}`);
+        axios.post(`https://${shop}/admin/oauth/access_token`, accessTokenPayload, { timeout: 30000, headers: { 'Content-Type': 'application/json;charset=UTF-8', 'Content-Security-Policy': `frame-ancestors https://${shop} https://admin.shopify.com;` } })
+            .then((accessTokenResponse) => {
+                const accessToken = accessTokenResponse.data.access_token;
+                successCallback(accessToken);
+            }).catch((error) => {
+                Logger.error(`getOathToken - ${error.message} --- ${error.error ? error.error.error_description : error.error }  ---  ${error.response ? error.response.data : 'no response data'}`);
+                failureCalback(error.statusCode, error.error ? error.error.error_description : error.error );
+            });
+    }
+}

package/shopify/router/services/RestUtils.ts

@@ -0,0 +1,13 @@
+export default class RestUtils {
+    public static getShopFromRequestHeaders = (req: any): string =>  {
+        if(!req || !req.headers)
+            throw new Error('It is not a http request object');
+
+        const shop = req.headers['x-shopify-shop-domain'];
+
+        if(!shop) 
+            throw new Error('There is not shop in request header!');
+        else 
+            return shop;
+    };
+}

package/shopify/router/services/rateLimiter/MemoryStores.ts

@@ -0,0 +1,46 @@
+
+export default class MemoryStore {
+
+    private interval: NodeJS.Timer;
+    private hits = {};
+    private resetTime: Date;
+    
+    constructor(private windowMs: number) { 
+        this.resetTime = this.calculateNextResetTime(this.windowMs);
+        this.interval = setInterval(this.resetAll, this.windowMs);
+        if(this.interval.unref) {
+            this.interval.unref();
+        }
+    }
+
+    public incr = (key: string, cb: any): void => {
+        if (this.hits[key]) {
+            this.hits[key]++;
+        } else {
+            this.hits[key] = 1;
+        }
+        cb(null, this.hits[key], this.resetTime);
+    };
+
+    private calculateNextResetTime(windowMs: number): Date {
+        const d = new Date();
+        d.setMilliseconds(d.getMilliseconds() + windowMs);
+        return d;
+    }
+
+    public decrement = (key: string): void => {
+        if (this.hits[key]) {
+            this.hits[key]--;
+        }
+    };
+
+    public resetAll = (): void => {
+        this.hits = {};
+        this.resetTime = this.calculateNextResetTime(this.windowMs);
+    };
+
+    public resetKey = (key: string): void => {
+        delete this.hits[key];
+        delete this.resetTime[key];
+    };
+}