@webresto/graphql 1.3.6 → 1.3.8

package/src/additionalResolvers.ts

@@ -2,56 +2,119 @@ const DataLoader = require('dataloader');
 
 export const additionalResolver = {
   GroupModifier: {
-    group: async (parent, args, context, info) => {
-      if (!parent.modifierId) return;
+    modifierId: async (parent: { modifierId?: string;  id?: string /** here id means rmsID */}, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
+      if (parent.modifierId) return parent.modifierId;
+      
       if (!context.dataloaders) context.dataloaders = new WeakMap();
       const dataloaders = context.dataloaders;
 
       let dl = dataloaders.get(info.fieldNodes);
       if (!dl) {
-        dl = new DataLoader(async (ids: any) => {
-          const rows = await Group.find({id: ids});
-          const sortedInIdsOrder = ids.map(id => rows.find(x => x.id === id));
+        dl = new DataLoader(async (id: any) => {
+          const rows = await Group.find({
+            rmsId: id, isDeleted: false
+          });
+          const sortedInIdsOrder = id.map((id: string) => rows.find(x => {
+            return x.rmsId === id
+          }));
           return sortedInIdsOrder;
         });
         dataloaders.set(info.fieldNodes, dl);
       }
-      return dl.load(parent.modifierId);
+      return (await dl.load(parent.id)).id;
     },
+    group: async (parent: { modifierId?: string; id?: string /** here id means rmsID */ }, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
+      if (!parent.modifierId && !parent.id) return;
+      if (!context.dataloaders) context.dataloaders = new WeakMap();
+      const dataloaders = context.dataloaders;
+
+      let dl = dataloaders.get(info.fieldNodes);
+      if (!dl) {
+        dl = new DataLoader(async (ids: any) => {
+          const rows = await Group.find({
+            where: {
+              or: [{id: ids, isDeleted: false}, {rmsId: ids, isDeleted: false}] } 
+            } 
+          );
+          const sortedInIdsOrder = ids.map((id: string) => rows.find(x => x.id === id));
+          return sortedInIdsOrder;
+        });
+        dataloaders.set(info.fieldNodes, dl);
+      }
+      return await dl.load(parent.modifierId ? parent.modifierId : parent.id);
+    }
   },
   Modifier: {
-    dish: async (parent, args, context, info) => {
-      if (!parent.modifierId) return;
+    modifierId: async (parent: { modifierId?: string;  id?: string /** here id means rmsID */}, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
+      if (parent.modifierId) return parent.modifierId;
+      
       if (!context.dataloaders) context.dataloaders = new WeakMap();
       const dataloaders = context.dataloaders;
 
       let dl = dataloaders.get(info.fieldNodes);
       if (!dl) {
-        dl = new DataLoader(async (ids: any) => {
-          const rows = await Dish.find({id: ids, balance: { "!=": 0 }, isDeleted: false});
-          const sortedInIdsOrder = ids.map(id => rows.find(x => x.id === id));
+        dl = new DataLoader(async (id: any) => {
+          const rows = await Dish.find({
+            rmsId: id, balance: { "!=": 0 }, isDeleted: false
+          });
+          const sortedInIdsOrder = id.map((id: string) => rows.find(x => {
+            return x.rmsId === id
+          }));
+          return sortedInIdsOrder;
+        });
+        dataloaders.set(info.fieldNodes, dl);
+      }
+      return (await dl.load(parent.id)).id;
+    },
+    dish: async (parent: { modifierId?: string;  id?: string /** here id means rmsID */}, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
+      if (!parent.modifierId && !parent.id) return;
+      if (!context.dataloaders) context.dataloaders = new WeakMap();
+      const dataloaders = context.dataloaders;
+
+      let dl = dataloaders.get(info.fieldNodes);
+      if (!dl) {
+        dl = new DataLoader(async (id: any) => {
+          const rows = await Dish.find({ where: 
+            {or: [
+              {id: id, balance: { "!=": 0 }, isDeleted: false},
+              {rmsId: id, balance: { "!=": 0 }, isDeleted: false}
+            ]}
+          });
+          const sortedInIdsOrder = id.map((id: string) => rows.find(x => {
+            return x.id === id ? x.id === id : x.rmsId === id ? x.rmsId === id : false
+          }));
           return sortedInIdsOrder;
         });
-        // ложим инстанс дата-лоадера в WeakMap для повторного использования
         dataloaders.set(info.fieldNodes, dl);
       }
-      // юзаем метод `load` из нашего дата-лоадера
-      return dl.load(parent.modifierId);
-      // return await Dish.findOne({id: parent.modifierId}).populateAll();
+      return await dl.load(parent.modifierId ? parent.modifierId : parent.id);
     }
   },
 
   OrderModifier: {
-    dish: async (parent, args, context, info) => {
-      return (await Dish.find({id: parent.id, balance: { "!=": 0 }, isDeleted: false}).populateAll())[0];
+    dish: async (parent: { id: string; modifierId: string}, args: any, context: any, info: any) => {
+      if (!parent.id && !parent.modifierId) return null
+      return (await Dish.find({ where: 
+        {or: [
+          {id: parent.id, balance: { "!=": 0 }, isDeleted: false}, 
+          {rmsId: parent.id, balance: { "!=": 0 }, isDeleted: false}
+        ]}
+      // @ts-ignore //TODO: Deprecated populateAll 
+      }).populateAll())[0];
     },
-    group: async (parent, args) => {
-      return (await Group.find({id: parent.groupId, isDeleted: false}).populateAll())[0];
+    group: async (parent: { id: string, groupId: string; }, args: any) => {
+      if (!parent.id && !parent.groupId) return null
+      return (await Group.find(
+        {where: {
+          or: [{id: parent.groupId, isDeleted: false}, {rmsId: parent.id, isDeleted: false}] } 
+        }
+        // @ts-ignore //TODO: Deprecated populateAll 
+        ).populateAll())[0];
     }
   },
 
   Dish: {
-    parentGroup: async (parent, args, context, info) => {
+    parentGroup: async (parent: { parentGroup: any; }, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
       if (!parent.parentGroup) return;
       if (!context.dataloaders) context.dataloaders = new WeakMap();
       const dataloaders = context.dataloaders;
@@ -63,14 +126,22 @@ export const additionalResolver = {
 
       let dl = dataloaders.get(info.fieldNodes);
       if (!dl) {
-        dl = new DataLoader(async (id: any) => {
-          return await Group.find(id);
+        dl = new DataLoader(async (ids: any) => {
+          // Waterline can return data not by ids array sorting
+          return (await Group.find(ids)).sort((a, b) => ids.indexOf(a.id) - ids.indexOf(b.id));  
         });
         dataloaders.set(info.fieldNodes, dl);
       }
       return await dl.load(parent.parentGroup);
     },
-    images: async (parent, args, context, info) => {
+    images: async (parent: { id: any; }, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
+      
+      const sortImages = (images) => {
+        return images.sort((a, b) => {
+          return (+new Date(b.uploadDate) - +new Date(a.uploadDate));
+        });
+      };
+
       if (!parent.id) return;
       if (!context.dataloaders) context.dataloaders = new WeakMap();
       const dataloaders = context.dataloaders;
@@ -79,16 +150,16 @@ export const additionalResolver = {
       if (!dl) {
         dl = new DataLoader(async (ids: any) => {
           const rows = await Dish.find({id: ids}).populate('images');
-          const images = ids.map(id => rows.find(x => x.id === id)?.images);
+          const images = ids.map((id: string) => rows.find(x => x.id === id)?.images);
           return images;
         });
         dataloaders.set(info.fieldNodes, dl);
       }
-      return await dl.load(parent.id);
+      return sortImages(await dl.load(parent.id));
     }
   },
   Group: {
-    parentGroup: async (parent, args, context, info) => {
+    parentGroup: async (parent: { parentGroup: any; }, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
       if (!parent.parentGroup) return;
       if (!context.dataloaders) context.dataloaders = new WeakMap();
       const dataloaders = context.dataloaders;
@@ -100,8 +171,8 @@ export const additionalResolver = {
 
       let dl = dataloaders.get(info.fieldNodes);
       if (!dl) {
-        dl = new DataLoader(async (id: any) => {
-          return await Group.find(id);
+        dl = new DataLoader(async (ids: any) => {
+          return (await Group.find(ids)).sort((a, b) => ids.indexOf(a.id) - ids.indexOf(b.id));  
         });
         dataloaders.set(info.fieldNodes, dl);
       }
@@ -109,18 +180,17 @@ export const additionalResolver = {
     }
   },
   Order: {
-    dishes: async (parent, args, context, info) => {
+    dishes: async (parent: { dishes: any; id: any; }, args: any, context: any, info: any) => {
       if (typeof parent.dishes === "object") {
         return parent.dishes;
       }
 
       return await OrderDish.find({order: parent.id});
-        
     },
 
   },
   OrderDish: {
-    dish: async (parent, args, context, info) => {
+    dish: async (parent: { dish: any; }, args: any, context: { dataloaders: WeakMap<object, any>; }, info: { fieldNodes: any; }) => {
       
       if (!parent.dish) return;
       if (!context.dataloaders) context.dataloaders = new WeakMap();
@@ -132,13 +202,14 @@ export const additionalResolver = {
 
       let dl = dataloaders.get(info.fieldNodes);
       if (!dl) {
-        dl = new DataLoader(async (dishId: string) => {
-          return await Dish.find({id: dishId}).sort('id ASC');
+        dl = new DataLoader(async (ids: any) => {
+          return (await Dish.find(ids)).sort((a, b) => ids.indexOf(a.id) - ids.indexOf(b.id));  
         });
         dataloaders.set(info.fieldNodes, dl);
       }
       return await dl.load(parent.dish);
     },
     
-  },
+  }
 }
+

package/src/graphql.d.ts

@@ -1,7 +1,9 @@
+import { ApolloServer } from "apollo-server-express";
+import { PubSub } from "apollo-server";
 declare const _default: {
-    getPubsub: () => any;
-    getServer: () => any;
+    getPubsub: () => PubSub;
+    getServer: () => ApolloServer;
     addAdditionalResolver: (resolver: any) => void;
-    init: () => Promise<any>;
+    init: () => Promise<ApolloServer>;
 };
 export default _default;

package/src/graphql.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const helper = require("../lib/graphqlHelper");
-const getEmitter_1 = require("@webresto/core/libs/getEmitter");
 const _ = require("lodash");
 const additionalResolvers_1 = require("./additionalResolvers");
-const { ApolloServer } = require('apollo-server-express');
-const fs = require('fs');
-const path = require('path');
-const { PubSub } = require('apollo-server');
-const pubsub = new PubSub();
+const langParser = require("accept-language-parser");
+const apollo_server_express_1 = require("apollo-server-express");
+const fs = require("fs");
+const path = require("path");
+var i18nFactory = require('i18n-2');
+const apollo_server_1 = require("apollo-server");
+const pubsub = new apollo_server_1.PubSub();
 sails.graphql = { pubsub };
 let server;
 const AdditionalResolvers = {};
@@ -19,8 +20,7 @@ exports.default = {
         _.merge(AdditionalResolvers, resolver);
     },
     init: async function () {
-        var _a, _b;
-        let resolversApiPath = path.resolve(__dirname, './resolvers');
+        let resolversApiPath = path.resolve(__dirname, "./resolvers");
         if (fs.existsSync(resolversApiPath)) {
             helper.addDirResolvers(resolversApiPath);
         }
@@ -29,20 +29,19 @@ exports.default = {
             helper.addDirResolvers(resolversApiPath);
         }
         helper.addAllSailsModels();
-        if ((_a = sails.config.restographql) === null || _a === void 0 ? void 0 : _a.whiteListAutoGen)
+        if (sails.config.restographql?.whiteListAutoGen)
             helper.setWhiteList(sails.config.restographql.whiteListAutoGen);
-        if ((_b = sails.config.restographql) === null || _b === void 0 ? void 0 : _b.blackList)
+        if (sails.config.restographql?.blackList)
             helper.addToBlackList(sails.config.restographql.blackList);
         // console.dir(autoGenerate, {depth: null});
         _.merge(AdditionalResolvers, additionalResolvers_1.additionalResolver);
         helper.addType(`
-
     input Customer {
-      phone: Phone
+      phone: InputPhone
       mail: String
       name: String!
     }
-    input Phone {
+    input InputPhone {
       code: String!
       number: String!
       additionalNumber: String
@@ -61,11 +60,13 @@ exports.default = {
       doorphone: String
     }
     type Message {
+      id: String
       title: String
       type: String
       message: String
     }
     type Action {
+      id: String
       type: String
       data: Json
     }
@@ -74,16 +75,63 @@ exports.default = {
       message: Message
       action: Action
     }
+    type Response {
+      message: Message
+      action: Action
+    }
     type GetOrderResponse {
       order: Order
       customData: Json
     }
-    type Restrictions {
-      workTime: Json
-      periodPossibleForOrder: Json
-      timezone: Json
-      deliveryDescription: Json
-      minDeliveryTime: Json
+
+    type UserCustomField {
+      id: String
+      type: String
+      label: String
+      enum: [String]
+      description: String
+      required: Boolean
+      regex: String
+    }
+
+
+    type Phone {
+      code: String
+      number: String
+      additionalNumber: String
+    }    
+    type CaptchaJob {
+      id: String
+      task: String
+    }
+    type PromotionState {
+      type: String
+      message: String
+      state: Json
+    }
+
+    """Solved captcha"""
+    input Captcha {
+      "Captcha job ID"
+      id: String!
+      "Resolved captcha"
+      solution: String!
+    }
+
+    """Country"""
+    type Country {
+      phoneCode: String
+      iso: String
+      name: String
+      nativeCountryName: String
+      language: [String]
+      currency: String
+      currencySymbol: String
+      currencyISO: String
+      currencyUnit: String
+      currencyDenomination: Int
+      phoneMask: [String]
+      flag: String
     }
     `);
         // helper.addToBlackList(["createdAt", "updatedAt"]);
@@ -99,59 +147,144 @@ exports.default = {
         _root: String
       }`);
         /**
-        * Discount fields global support
-        */
+         * Discount fields global support
+         */
         helper.addCustomField("Dish", "discountAmount: Float");
         helper.addCustomField("Dish", "discountType: String");
+        /**
+         * @deprecated ???
+         */
         helper.addCustomField("Dish", "oldPrice: Float");
+        helper.addCustomField("Dish", "salePrice: Float");
         helper.addCustomField("Group", "discount: String");
+        /**
+         * Types of complex order fields
+         */
+        helper.addType(`#graphql
+      type OrderDeliveryState {
+        "Time it will take for delivery"
+        deliveryTimeMinutes: Int
+        "If disabled, then delivery is not allowed and will be processed"
+        allowed: Boolean
+        "Cost of delivery"
+        cost: Float
+        "ID of the service that will be on the delivery receipt"
+        item: String
+        "Server message for current delivery"
+        message: String
+      }`);
+        helper.addToReplaceList("Order.delivery", "delivery: OrderDeliveryState");
         const { typeDefs, resolvers } = helper.getSchema();
-        getEmitter_1.default().on('core-order-after-count', 'graphql', function (order) {
+        emitter.on("core-order-after-count", "graphql", function (order) {
             pubsub.publish("order-changed", order);
         });
-        getEmitter_1.default().on("send-message", "graphql", function ({ orderId, message }) {
+        emitter.on("send-message", "graphql", function ({ orderId, message }) {
             pubsub.publish("message", { orderId, message });
         });
-        getEmitter_1.default().on("core-dish-after-update", "graphql", function (record) {
+        emitter.on("core-dish-after-update", "graphql", function (record) {
             pubsub.publish("dish-changed", record);
         });
-        getEmitter_1.default().on("core-maintenance-enabled", "graphql", function (record) {
+        emitter.on("core-maintenance-enabled", "graphql", function (record) {
             pubsub.publish("maintenance", record);
         });
-        getEmitter_1.default().on("core-maintenance-disabled", "graphql", function () {
+        emitter.on("core-maintenance-disabled", "graphql", function () {
             pubsub.publish("maintenance", null);
         });
         let apolloServer;
         try {
-            apolloServer = new ApolloServer({
+            apolloServer = new apollo_server_express_1.ApolloServer({
                 typeDefs,
+                introspection: true,
+                playground: true,
                 resolvers: [resolvers, AdditionalResolvers],
                 subscriptions: {
                     onConnect: (connectionParams, webSocket) => {
                         let exContext = {};
                         if (connectionParams) {
-                            if (!connectionParams['authorization'] && connectionParams['Authorization'])
-                                connectionParams['authorization'] = connectionParams['Authorization'];
-                            exContext['connectionParams'] = connectionParams;
+                            /**
+                             * Authorization
+                             */
+                            if (!connectionParams["authorization"] && connectionParams["Authorization"]) {
+                                connectionParams["authorization"] = connectionParams["Authorization"];
+                            }
+                            if (connectionParams["x-device-id"] || connectionParams["X-Device-Id"]) {
+                                connectionParams["deviceId"] = connectionParams["x-device-id"] ? connectionParams["x-device-id"] : connectionParams["X-Device-Id"];
+                            }
+                            exContext["connectionParams"] = connectionParams;
+                            /**
+                             * Accept-Language
+                             */
+                            connectionParams["locale"] = sails.config.i18n.defaultLocale;
+                            const acceptLanguge = connectionParams["Accept-Language"] ?? connectionParams["accept-language"] ?? false;
+                            if (acceptLanguge) {
+                                connectionParams["locale"] = langParser.parse(acceptLanguge)[0]?.code ?? sails.config.i18n.defaultLocale;
+                            }
+                            const i18n = new i18nFactory({ ...sails.config.i18n, directory: sails.config.i18n.localesDirectory, extension: ".json" });
+                            i18n.setLocale(connectionParams["locale"]);
+                            exContext["i18n"] = i18n;
                         }
-                        exContext['pubsub'] = pubsub;
+                        exContext["pubsub"] = pubsub;
                         return exContext;
                     },
                 },
-                context: async ({ req, connection }) => {
-                    if (connection) {
+                formatError: (error) => {
+                    const graphQLFormattedError = {
+                        message: `${error.path}: ${error.message}`,
+                        ...process.env.NODE_ENV !== "production" && {
+                            locations: error.extensions.exception.stacktrace,
+                            path: error.path
+                        },
+                    };
+                    return graphQLFormattedError;
+                },
+                context: ({ req, connection }) => {
+                    if (connection && connection.context) {
                         return connection.context;
                     }
                     else {
-                        return { ...req };
+                        const headers = {};
+                        if (req?.rawHeaders) {
+                            for (let i = 0; i < req.rawHeaders.length; i += 2) {
+                                const name = req.rawHeaders[i];
+                                const value = req.rawHeaders[i + 1];
+                                headers[name.toLowerCase()] = value;
+                            }
+                        }
+                        if (headers["x-device-id"] || headers["X-Device-Id"]) {
+                            headers["deviceId"] = headers["x-device-id"] ? headers["x-device-id"] : headers["X-Device-Id"];
+                        }
+                        if (!headers["authorization"] && headers["Authorization"]) {
+                            headers["authorization"] = headers["Authorization"];
+                        }
+                        // set context locale
+                        headers["locale"] = sails.config.i18n.defaultLocale;
+                        const acceptLanguge = headers["Accept-Language"] ?? headers["accept-language"] ?? false;
+                        if (acceptLanguge) {
+                            headers["locale"] = (langParser.parse(acceptLanguge))[0]?.code ?? sails.config.i18n.defaultLocale;
+                        }
+                        const i18n = new i18nFactory({ ...sails.config.i18n, directory: sails.config.i18n.localesDirectory, extension: ".json" });
+                        i18n.setLocale(headers["locale"]);
+                        return { ...req, connectionParams: headers, i18n: i18n };
                     }
-                }
+                },
             });
         }
         catch (error) {
-            console.error("GraphQL start error: ", error);
+            if (error.locations && error.locations[0].line) {
+                typeDefs.split("\n").forEach((item, i) => {
+                    if (Math.abs(error.locations[0].line - i) < 10) {
+                        console.log(i, `|`, item);
+                        if (error.locations[0].line - 1 === i) {
+                            console.log("_______________");
+                        }
+                    }
+                });
+                console.log(`ERROR LINE: ${error.locations[0].line} `, typeDefs.split("\n", -1)[error.locations[0].line - 1]);
+            }
+            console.error(JSON.stringify(error));
+            throw error;
         }
         server = apolloServer;
         return apolloServer;
-    }
+    },
 };