@webresto/graphql 1.3.0

package/src/graphql.js

@@ -0,0 +1,144 @@
+"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();
+sails.graphql = { pubsub };
+let server;
+const AdditionalResolvers = {};
+exports.default = {
+    getPubsub: () => pubsub,
+    getServer: () => server,
+    addAdditionalResolver: (resolver) => {
+        _.merge(AdditionalResolvers, resolver);
+    },
+    init: async function () {
+        var _a, _b;
+        let resolversApiPath = path.resolve(__dirname, './resolvers');
+        if (fs.existsSync(resolversApiPath)) {
+            helper.addDirResolvers(resolversApiPath);
+        }
+        resolversApiPath = path.resolve(process.cwd(), "./api/resolvers");
+        if (fs.existsSync(resolversApiPath)) {
+            helper.addDirResolvers(resolversApiPath);
+        }
+        helper.addAllSailsModels();
+        if ((_a = sails.config.restographql) === null || _a === void 0 ? void 0 : _a.whiteListAutoGen)
+            helper.setWhiteList(sails.config.restographql.whiteListAutoGen);
+        if ((_b = sails.config.restographql) === null || _b === void 0 ? void 0 : _b.blackList)
+            helper.addToBlackList(sails.config.restographql.blackList);
+        // console.dir(autoGenerate, {depth: null});
+        _.merge(AdditionalResolvers, additionalResolvers_1.additionalResolver);
+        helper.addType(`
+
+    input Customer {
+      phone: Phone
+      mail: String
+      name: String!
+    }
+    input Phone {
+      code: String!
+      number: String!
+      additionalNumber: String
+    }
+    input Address {
+      streetId: String
+      home: String
+      comment: String
+      city: String
+      street: String
+      housing: String
+      index: String
+      entrance: String
+      floor: String
+      apartment: String
+      doorphone: String
+    }
+    type Message {
+      title: String
+      type: String
+      message: String
+    }
+    type Action {
+      type: String
+      data: Json
+    }
+    type CheckResponse {
+      order: Order
+      message: Message
+      action: Action
+    }
+    type GetOrderResponse {
+      order: Order
+      customData: Json
+    }
+    type Restrictions {
+      workTime: Json
+      periodPossibleForOrder: Json
+      timezone: Json
+      deliveryDescription: Json
+      minDeliveryTime: Json
+    }
+    `);
+        // helper.addToBlackList(["createdAt", "updatedAt"]);
+        // required root types for moduling schema
+        helper.addType(`
+      type Query {
+        _root: String
+      }
+      type Mutation {
+        _root: String
+      }
+      type Subscription {
+        _root: String
+      }`);
+        const { typeDefs, resolvers } = helper.getSchema();
+        getEmitter_1.default().on('core-order-after-count', 'graphql', function (order) {
+            pubsub.publish("order-changed", order);
+        });
+        getEmitter_1.default().on("send-message", "graphql", function ({ orderId, message }) {
+            pubsub.publish("message", { orderId, message });
+        });
+        getEmitter_1.default().on("core-dish-after-update", "graphql", function (record) {
+            pubsub.publish("dish-changed", record);
+        });
+        getEmitter_1.default().on("core-maintenance-enabled", "graphql", function (record) {
+            pubsub.publish("maintenance", record);
+        });
+        getEmitter_1.default().on("core-maintenance-disabled", "graphql", function () {
+            pubsub.publish("maintenance", null);
+        });
+        const apolloServer = new ApolloServer({
+            typeDefs,
+            resolvers: [resolvers, AdditionalResolvers],
+            subscriptions: {
+                onConnect: (connectionParams, webSocket) => {
+                    let exContext = {};
+                    if (connectionParams) {
+                        if (!connectionParams['authorization'] && connectionParams['Authorization'])
+                            connectionParams['authorization'] = connectionParams['Authorization'];
+                        exContext['connectionParams'] = connectionParams;
+                    }
+                    exContext['pubsub'] = pubsub;
+                    return exContext;
+                },
+            },
+            context: async ({ req, connection }) => {
+                if (connection) {
+                    return connection.context;
+                }
+                else {
+                    return { ...req };
+                }
+            }
+        });
+        server = apolloServer;
+        return apolloServer;
+    }
+};

package/src/graphql.ts

@@ -0,0 +1,160 @@
+import * as helper from '../lib/graphqlHelper';
+import getEmitter from "@webresto/core/libs/getEmitter";
+import _ = require("lodash");
+import { additionalResolver } from './additionalResolvers';
+
+const { ApolloServer } = require('apollo-server-express');
+const fs = require('fs');
+const path = require('path');
+
+const { PubSub } = require('apollo-server');
+const pubsub = new PubSub();
+sails.graphql = { pubsub };
+let server;
+
+const AdditionalResolvers: any = {
+}
+
+export default {
+  getPubsub: () => pubsub,
+  getServer: () => server,
+  addAdditionalResolver: (resolver) => {
+    _.merge(AdditionalResolvers, resolver);
+  },
+  init: async function () {
+    let resolversApiPath = path.resolve(__dirname, './resolvers');
+    if (fs.existsSync(resolversApiPath)) {
+      helper.addDirResolvers(resolversApiPath);
+    }
+    resolversApiPath = path.resolve(process.cwd(), "./api/resolvers");
+    if (fs.existsSync(resolversApiPath)) {
+      helper.addDirResolvers(resolversApiPath);
+    }
+
+    helper.addAllSailsModels();
+
+    if (sails.config.restographql?.whiteListAutoGen)
+      helper.setWhiteList(
+        sails.config.restographql.whiteListAutoGen
+      );
+
+    if (sails.config.restographql?.blackList)
+      helper.addToBlackList(sails.config.restographql.blackList);
+    // console.dir(autoGenerate, {depth: null});
+
+    _.merge(AdditionalResolvers, additionalResolver);
+
+    helper.addType(`
+
+    input Customer {
+      phone: Phone
+      mail: String
+      name: String!
+    }
+    input Phone {
+      code: String!
+      number: String!
+      additionalNumber: String
+    }
+    input Address {
+      streetId: String
+      home: String
+      comment: String
+      city: String
+      street: String
+      housing: String
+      index: String
+      entrance: String
+      floor: String
+      apartment: String
+      doorphone: String
+    }
+    type Message {
+      title: String
+      type: String
+      message: String
+    }
+    type Action {
+      type: String
+      data: Json
+    }
+    type CheckResponse {
+      order: Order
+      message: Message
+      action: Action
+    }
+    type GetOrderResponse {
+      order: Order
+      customData: Json
+    }
+    type Restrictions {
+      workTime: Json
+      periodPossibleForOrder: Json
+      timezone: Json
+      deliveryDescription: Json
+      minDeliveryTime: Json
+    }
+    `);
+
+
+    // helper.addToBlackList(["createdAt", "updatedAt"]);
+
+    // required root types for moduling schema
+    helper.addType(`
+      type Query {
+        _root: String
+      }
+      type Mutation {
+        _root: String
+      }
+      type Subscription {
+        _root: String
+      }`);
+
+    const { typeDefs, resolvers } = helper.getSchema();
+
+    getEmitter().on('core-order-after-count', 'graphql', function (order) {
+      pubsub.publish("order-changed", order);
+    });
+    getEmitter().on("send-message", "graphql", function ({ orderId, message }) {
+      pubsub.publish("message", { orderId, message });
+    });
+    getEmitter().on("core-dish-after-update", "graphql", function (record) {
+      pubsub.publish("dish-changed", record);
+    });
+    getEmitter().on("core-maintenance-enabled", "graphql", function (record) {
+      pubsub.publish("maintenance", record);
+    });
+    getEmitter().on("core-maintenance-disabled", "graphql", function () {
+      pubsub.publish("maintenance", null);
+    });
+
+    const apolloServer = new ApolloServer({
+      typeDefs,
+      resolvers: [resolvers, AdditionalResolvers],
+      subscriptions: {
+        onConnect: (connectionParams, webSocket) => {
+          let exContext = {}
+          if (connectionParams) {
+            if (!connectionParams['authorization'] && connectionParams['Authorization'])
+              connectionParams['authorization'] = connectionParams['Authorization'];
+
+            exContext['connectionParams'] = connectionParams
+          }
+            exContext['pubsub'] = pubsub;
+            return exContext;
+        },
+      },
+      context: async ({ req , connection}) => {
+        if (connection) {
+          return connection.context;
+        } else {
+          return { ...req };
+        }
+      }
+    });
+
+    server = apolloServer;
+    return apolloServer;
+  }
+}

package/src/resolvers/cart.d.ts

@@ -0,0 +1,123 @@
+declare const _default: {
+    Query: {
+        order: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<{
+                id: string;
+                shortId: string;
+                dishes: number[] | import("@webresto/core/models/OrderDish").default[];
+                discount: any;
+                paymentMethod: any;
+                paymentMethodTitle: string;
+                paid: {
+                    type: string;
+                    defaultsTo: boolean;
+                };
+                isPaymentPromise: boolean;
+                dishesCount: number;
+                uniqueDishes: number;
+                modifiers: any;
+                customer: any;
+                address: any;
+                comment: string;
+                personsCount: string;
+                date: string;
+                problem: boolean;
+                rmsDelivered: boolean;
+                rmsId: string;
+                rmsOrderNumber: string;
+                rmsOrderData: any;
+                rmsDeliveryDate: string;
+                rmsErrorMessage: string;
+                rmsErrorCode: string;
+                rmsStatusCode: string;
+                deliveryStatus: string;
+                selfService: boolean;
+                deliveryDescription: string;
+                message: string;
+                deliveryItem: any;
+                deliveryCost: number;
+                totalWeight: number;
+                total: number;
+                trifleFrom: number;
+                orderTotal: number;
+                discountTotal: number;
+                orderDate: string;
+                customData: any;
+                state: string;
+                toJSON(): any;
+            }>;
+        };
+    };
+    Mutation: {
+        orderAddDish: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/Order").default>;
+        };
+        orderReplaceDish: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/Order").default>;
+        };
+        orderRemoveDish: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/Order").default>;
+        };
+        orderSetDishAmount: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/Order").default>;
+        };
+        orderSetDishComment: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/Order").default>;
+        };
+        orderUpdate: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<{
+                id: string;
+                shortId: string;
+                dishes: number[] | import("@webresto/core/models/OrderDish").default[];
+                discount: any;
+                paymentMethod: any;
+                paymentMethodTitle: string;
+                paid: {
+                    type: string;
+                    defaultsTo: boolean;
+                };
+                isPaymentPromise: boolean;
+                dishesCount: number;
+                uniqueDishes: number;
+                modifiers: any;
+                customer: any;
+                address: any;
+                comment: string;
+                personsCount: string;
+                date: string;
+                problem: boolean;
+                rmsDelivered: boolean;
+                rmsId: string;
+                rmsOrderNumber: string;
+                rmsOrderData: any;
+                rmsDeliveryDate: string;
+                rmsErrorMessage: string;
+                rmsErrorCode: string;
+                rmsStatusCode: string;
+                deliveryStatus: string;
+                selfService: boolean;
+                deliveryDescription: string;
+                message: string;
+                deliveryItem: any;
+                deliveryCost: number;
+                totalWeight: number;
+                total: number;
+                trifleFrom: number;
+                orderTotal: number;
+                discountTotal: number;
+                orderDate: string;
+                customData: any;
+                state: string;
+                toJSON(): any;
+            }>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/cart.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const checkExpression_1 = require("@webresto/core/libs/checkExpression");
+const getEmitter_1 = require("@webresto/core/libs/getEmitter");
+const errorWrapper_1 = require("../../lib/errorWrapper");
+exports.default = {
+    Query: {
+        order: {
+            def: '""" если orderId не задан, вернется новая корзина """ order(orderId: String, shortId: String, orderNumber: String): Order',
+            fn: async function (parent, args, context) {
+                let order;
+                let criteria = {};
+                if (args.orderNumber) {
+                    criteria["rmsOrderNumber"] = args.orderNumber;
+                    criteria["sort"] = "createdAt DESC";
+                }
+                else if (args.orderId) {
+                    criteria["id"] = args.orderId;
+                }
+                else if (args.shortId) {
+                    criteria["shortId"] = args.shortId;
+                }
+                if (Object.keys(criteria).length !== 0) {
+                    order = (await Order.find(criteria))[0];
+                }
+                if (!order) {
+                    sails.log.error("GQL > order resolver error: ", `order with id ${args.orderId} . Trying make new cart.`);
+                    order = await getNewCart(args.orderId);
+                }
+                return await Order.populate(order.id);
+            },
+        },
+    },
+    Mutation: {
+        orderAddDish: {
+            def: "orderAddDish(orderId: String, dishId: String, amount: Int, modifiers: Json, comment: String, from: String, replace: Boolean, orderDishId: Int): Order",
+            fn: async function (parent, args, context) {
+                let order;
+                if (args.modifiers) {
+                    args.modifiers.forEach((modifier) => {
+                        if (modifier.amount === undefined || modifier.id === undefined)
+                            throw new errorWrapper_1.Error(0, "ERROR", `modifier required (amount, id) for dish: ${args.dishId} current values: id: ${modifier.id}, amount: ${modifier.amount}`);
+                    });
+                }
+                if (args.orderId)
+                    order = await Order.findOne({ id: args.orderId });
+                if (!order) {
+                    sails.log.error("GQL > orderAddDish resolver error: ", `order with id ${args.orderId} has problem. Trying make new cart.`);
+                    order = await getNewCart(args.orderId);
+                }
+                const dish = await Dish.findOne({ id: args.dishId });
+                if (!dish && !args.replace)
+                    throw new errorWrapper_1.Error(0, "ERROR", `dish with id ${args.dishId} not found`);
+                if (dish && checkExpression_1.default(dish) === "promo") {
+                    let additionalInfo;
+                    try {
+                        additionalInfo = JSON.parse(dish.additionalInfo);
+                    }
+                    catch (e) { }
+                    if (additionalInfo && additionalInfo.defaultOrderDish) {
+                        // Исключение на товар в каждую корзину
+                    }
+                    else {
+                        throw new errorWrapper_1.Error(0, "ERROR", `"${dish.name}" является акционным и не может быть добавлено пользователем`);
+                    }
+                }
+                await Order.addDish(order.id, args.dishId, args.amount, args.modifiers || [], args.comment, args.from, args.replace, args.orderDishId);
+                return await Order.countCart(order);
+            },
+        },
+        orderReplaceDish: {
+            def: "orderReplaceDish(orderId: String!, orderDishId: Int!, amount: Int, modifiers: Json, comment: String, from: String): Order",
+            fn: async (parent, args, context) => {
+                let order;
+                if (args.orderId)
+                    order = await Order.findOne({ id: args.orderId });
+                if (!order) {
+                    sails.log.error("GQL > orderReplaceDish resolver error: ", `order with id ${args.orderId} has problem. Trying make new cart.`);
+                    order = await getNewCart(args.orderId);
+                }
+                if (order.paid || order.state === "ORDER") {
+                    order = await getNewCart();
+                }
+                await Order.addDish(order.id, args.dishId, args.amount, args.modifiers || [], args.comment, args.from, args.replace, args.orderDishId);
+                return await Order.countCart(order);
+            },
+        },
+        orderRemoveDish: {
+            def: "orderRemoveDish(id: String!, orderDishId: Int!, amount: Int): Order",
+            fn: async function (parent, args, context) {
+                let order;
+                order = await Order.findOne({ id: args.id });
+                if (!order) {
+                    sails.log.error("GQL > orderRemoveDish resolver error: ", `order with id ${args.orderId} has problem. Trying make new cart.`);
+                    order = await getNewCart(args.orderId);
+                }
+                if (order.paid || order.state === "ORDER") {
+                    order = await getNewCart();
+                }
+                const orderDish = await OrderDish.findOne({ id: args.orderDishId });
+                await Order.removeDish(order.id, orderDish, args.amount, false);
+                return await Order.countCart(order);
+            },
+        },
+        orderSetDishAmount: {
+            def: "orderSetDishAmount(id: String, orderDishId: Int, amount: Int): Order",
+            fn: async function (parent, args, context) {
+                let order;
+                order = await Order.findOne(args.id);
+                if (!order) {
+                    sails.log.error("GQL > orderSetDishAmount resolver error: ", `order with id ${args.orderId} has problem. Trying make new cart.`);
+                    order = await getNewCart(args.orderId);
+                }
+                if (order.paid || order.state === "ORDER") {
+                    order = await getNewCart();
+                }
+                let dish = await OrderDish.findOne(args.orderDishId).populate("dish");
+                if (!dish)
+                    throw new errorWrapper_1.Error(0, "ERROR", `OrderDish with id ${args.orderDishId} not found`);
+                if (!dish.dish)
+                    throw new errorWrapper_1.Error(0, "ERROR", `Dish in OrderDish with id ${args.orderDishId} not found`);
+                await Order.setCount(order.id, dish, args.amount);
+                return await Order.countCart(order);
+            },
+        },
+        orderSetDishComment: {
+            def: "orderSetDishComment(id: String, orderDishId: Int, comment: String): Order",
+            fn: async function (parent, args, context) {
+                let order;
+                const data = args;
+                const orderId = data.orderId;
+                const comment = data.comment || "";
+                const dishId = data.dishId;
+                if (!dishId) {
+                    throw new errorWrapper_1.Error(0, "ERROR", "dishId is required");
+                }
+                order = await Order.findOne(orderId);
+                if (!order) {
+                    sails.log.error("GQL > orderSetDishComment resolver error: ", `order with id ${args.orderId} has problem. Trying make new cart.`);
+                    order = await getNewCart(args.orderId);
+                }
+                if (order.paid || order.state === "ORDER") {
+                    order = await getNewCart();
+                }
+                const dish = await OrderDish.findOne({ id: dishId }).populate("dish");
+                if (!dish) {
+                    throw new errorWrapper_1.Error(0, "ERROR", `Dish with id ${dishId} not found`);
+                }
+                await order.setComment(dish, comment);
+                return await Order.countCart(order);
+            },
+        },
+        orderUpdate: {
+            def: '"""Experimental! allowed only for trifleFrom """ orderUpdate(order: Json): Order',
+            fn: async function (parent, args, context) {
+                let order = args.order;
+                if (!order.id)
+                    throw "order.id field is required";
+                await Order.update({ id: order.id }, { trifleFrom: order.trifleFrom });
+                return await Order.populate(order.id);
+            },
+        },
+    },
+};
+// Generate new cart
+async function getNewCart(orderId) {
+    let order;
+    let initOrder = {};
+    // Pass oredrId from frontend
+    if (orderId)
+        initOrder["id"] = orderId;
+    getEmitter_1.default().emit("http-api:init-newcart", initOrder);
+    order = await Order.create(initOrder).fetch();
+    await getEmitter_1.default().emit("http-api:create-newcart", order);
+    return order;
+}