@webresto/graphql 1.3.0

package/lib/graphqlHelper.ts

@@ -0,0 +1,692 @@
+/// <reference path="../../core/libs/globalTypes.ts"/>
+
+import _ = require("lodash");
+import { WorkTimeValidator} from '@webresto/worktime'
+import getEmitter from "@webresto/core/libs/getEmitter";
+import *  as WLCriteria from 'waterline-criteria';
+const fs = require('fs');
+const path = require('path');
+
+
+ const scalarTypes = {
+    string: "String",
+    text: "String",
+    date: "String",
+    datetime: "String",
+    integer: "Int",
+    float: "Float",
+    boolean: "Boolean",
+    // "json": "Json",
+    // "array": "Array",
+}
+
+/*
+const typeDefsExample = {
+    types: [
+        `type Example{
+            id: ID!
+            label: String
+            text: String
+        }`,
+        `type Dish{
+            name: String
+            description: String
+        }`
+    ],
+    resolvers: {
+        Query: {
+            example: {
+                def: 'example(id: ID!): Example',
+                fn: async function (parent, args, context){
+                    const example = await Example.find({id: args.id});
+                    return example[0];
+                },
+            },
+            dish: {
+                def: 'dish(id: ID!): Dish',
+                fn: async function (parent, args, context){
+                    return {
+                            id: 1,
+                            name: "test name",
+                            price: "150"
+                        }
+                }
+            }
+        }
+    }
+}
+*/
+
+const schemaResolvers = {};
+const schemaTypes = [];
+const schemaUnions = {};
+const schemaScalars: Set<string> = new Set();
+const blackList = [];
+const customFields = {};
+const replaceList = {};
+
+const models: Set<string> = new Set();
+
+/**
+ * Добавляет модель в список моделей для создания типов схемы graphql
+ *
+ *
+ * @param modelName string
+ * @returns void
+ */
+
+function addModel (modelName: string) {
+    modelName = firstLetterToUpperCase(modelName);
+    if (blackList.includes(modelName)) {
+        // schemaScalars.add(modelName);
+        return;
+    }
+    models.add(modelName.toLowerCase());
+}
+function addType (typeString: String) {
+    schemaTypes.push(typeString);
+}
+/**
+ * Мержит новый резолвер с объектом резолверов. Новый резолвер заменит старый при совпадении имен
+ *
+ * @param resolvers
+ * resolverExample = {
+ *      def: "user(id: String)",
+ *      fn: function (parent, args, context) {
+ *          return User.find({id: args.id})
+ *      }
+ * }
+ */
+function addResolvers (resolvers: Object) {
+    _.merge(schemaResolvers, resolvers);
+}
+
+/**
+ * Сканирует все модели sails и добавляет их в список моделей для создания типов схемы graphql
+ */
+function addAllSailsModels() {
+  Object.keys(sails.models).forEach((key) => {
+    if (key.includes("__")) return;
+    if (sails.models[key].graphql && sails.models[key].graphql.public === false){
+      addToBlackList([key]);
+      return;
+    }
+    addModel(key);
+  });
+}
+
+/**
+ * Добавляет массив с исключениями к текущему списку
+ * Варианты:
+ * 1. ["Order.field"] - исключает поле field в модели Order
+ * 2. ["Order"] - исключает модель Order полностью
+ * 3. ["field] - исключает поле field из всех моделей
+ *
+ * @param list array<string>
+ */
+function addToBlackList(list: Array<string>) {
+    blackList.push(...list);
+}
+
+/**
+ * Добавляет в указаную модель новое поле
+ * Пример: addCustomField("Order", "customField: String")
+ *
+ * @param model string
+ * @param field string
+ */
+function addCustomField(model, field) {
+  customFields[model] = customFields[model] === undefined ? "" : customFields[model]
+  customFields[model] += `${field}\n`;
+}
+
+/**
+ * Добавляет в список автозамены поле.
+ * Пример: addToReplaceList("Dish.image", "image: [Image]");
+ *
+ * @param model string
+ * @param field string
+ */
+function addToReplaceList(model, field) {
+    replaceList[model] = field;
+}
+
+/**
+ * Сканирует указанную директорию и добавляет найденные резолверсы в схему graphql
+ *
+ * @param dir
+ */
+function addDirResolvers(dir) {
+  let files = fs.readdirSync(dir);
+  for (let file of files) {
+    if (file.substr(-3) == ".js") {
+      const resolver = require(path.join(dir, file)).default;
+      if (resolver) {
+        addResolvers(resolver);
+      }
+    }
+  }
+}
+
+/**
+ * Запускает генерацию схемы и резолверсов
+ * Возвращает готовые данные для использования при инициализации apollo server
+ *
+ * @returns {schemaTypes, schemaResolvers}
+ */
+function getSchema () {
+  Object.keys(whiteList).forEach(modelname => {
+    if (sails.models[modelname]?.graphql?.public !== false) {
+      addModelResolver(modelname);
+    }
+  });
+
+  addResolvers(modelsResolvers);
+  return createSchema({types: schemaTypes, resolvers: schemaResolvers});
+}
+
+function firstLetterToUpperCase(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+function firstLetterToLowerCase(string) {
+  return string.charAt(0).toLowerCase() + string.slice(1);
+}
+
+/**
+ * Перебирает все поля модели и генерирует тип для схемы graphql
+ *
+ * @param model sails.model
+ * @returns string
+ */
+function createType(model) {
+  const modelName = model.globalId;
+  const attributes = model._attributes || model.attributes;
+  let type = 'type ' + modelName + '{\n';
+  for (let prop in attributes) {
+    if (blackList.includes(`${modelName}.${prop}`) || blackList.includes(prop))
+      continue;
+    if (replaceList[`${modelName}.${prop}`] || replaceList[prop]) {
+      const newField = replaceList[`${modelName}.${prop}`] || replaceList[prop];
+      type += `  ${newField}\n`;
+      continue;
+    }
+
+    let scalarType;
+    if (attributes[prop].type) {
+      if (scalarTypes[attributes[prop].type.toLowerCase()]) {
+        scalarType = scalarTypes[attributes[prop].type.toLowerCase()];
+      } else {
+        scalarType = firstLetterToUpperCase(attributes[prop].type);
+        schemaScalars.add(scalarType);
+      }
+      type += '  ' + prop + ': ' + scalarType + '\n';
+    }
+    
+    // MODEL SCHEMA GENERATION
+    if (attributes[prop].model) {
+      let relationModel = sails.models[attributes[prop].model.toLowerCase()]
+      scalarType = scalarTypes[relationModel.attributes[relationModel.primaryKey].type]
+      const name = sails.models[attributes[prop].model.toLowerCase()].globalId;
+      type += `  ${prop}: ${name}\n`;
+
+      // todelete
+      type += `  ${prop}Id: ${scalarType}\n`;
+    }
+
+    // COLLECTION SCHEMA GENERATION
+    if (attributes[prop].collection) {
+      scalarType = scalarTypes[attributes[sails.models[attributes[prop].collection.toLowerCase()].primaryKey].type.toLowerCase()]
+      const name = sails.models[attributes[prop].collection.toLowerCase()].globalId;
+      console.log(1,scalarType)
+      type += `  ${prop}: [${name}]\n`;
+
+      // todelete
+      type += `  ${prop}Ids: ${scalarType}\n`;
+    }
+  }
+  if (customFields[modelName]) {
+    type += `  ${customFields[modelName]}\n`;
+  }
+  if (!attributes.customData) {
+    type += '""" autogenerated """  customData: Json';
+  }
+  type += '}\n';
+  return type;
+}
+
+/**
+ * Соеденяет резолверсы и типы. Отделяет от резолверсов описание запросов.
+ * Возвращает готовую схему и резолверсы для использования в apollo server
+ *
+ * @param typeDefsObj
+ * @returns
+ */
+function createSchema(typeDefsObj) {
+  let schema = '';
+  const resolvers: Resolvers = {};
+  if (Array.isArray(typeDefsObj.types)) {
+    schema += typeDefsObj.types.join('\n');
+  }
+  // add types from models
+  for (let model of models) {
+    schema += createType(sails.models[model]);
+  }
+  // add union
+  for (let prop in schemaUnions) {
+    schema += `scalar ${prop}\n`;
+  }
+  // add scalar
+  for (let scalar of schemaScalars) {
+    schema += `scalar ${scalar}\n`;
+  }
+  // add resolver and type definition
+  if (typeDefsObj.resolvers) {
+    Object.keys(typeDefsObj.resolvers).forEach(key => {
+      resolvers[key] = {};
+      const res = typeDefsObj.resolvers[key];
+
+      if (['Query', 'Mutation', 'Subscription'].includes(key)) {
+        let typeString = `extend type ${key}{\n`;
+        for (let prop in res) {
+          typeString += '  ' + res[prop].def + '\n';
+          resolvers[key][prop] = res[prop].fn;
+        }
+        typeString += '}\n';
+        schema += '\n' + typeString;
+      } else {
+        if (res.def) {
+          schema += '\n' + res.def + '\n';
+        }
+        if (res.fn) {
+          resolvers[key] = res.fn;
+        } else {
+          resolvers[key] = res;
+        }
+      }
+    })
+  }
+  return { typeDefs: schema, resolvers };
+}
+
+
+// AUTOGENERATE RESOLVERS -----------------------------------------------
+
+// генерация резолверсов по списку моделей. Список моделей автоматически добавляется в схему.
+const whiteList = {
+  // group: ['subscription', 'query'] // order - modelname , 'subscription' - resolver type
+}
+const userAuth = typeof sails.config.restographql?.authService === 'function' ? sails.config.restographql.authService : null;
+
+let modelsResolvers: {Query?: Object, Subscription?: Object} = { Query: {}};
+const { withFilter } = require("apollo-server");
+
+/**
+ * Патчит waterline criteria во время автогенерации
+ *
+ * @param modelname
+ * @param criteria
+ * @returns
+ */
+function sanitizeCriteria(modelname, criteria) {
+
+  if (sails.models[modelname].attributes.enable){
+    criteria.enable = true;
+  }
+
+  if (sails.models[modelname].attributes.isDeleted){
+    criteria.isDeleted = false;
+  }
+
+  switch (modelname) {
+    case 'dish':
+      criteria.balance = {'!=': 0};
+      criteria.isDeleted = false;
+      break;
+    case 'group':
+      criteria.isDeleted = false;
+      break;
+  }
+  return criteria;
+}
+
+/**
+ * Добавляет whiteList
+ * Пример: setWhiteList({
+    page: ['query'],
+    promotion: ['query'],
+    maintenance: ['query', 'subscription']
+  })
+ *
+ * @param list
+ */
+function setWhiteList(list: Object) {
+  _.merge(whiteList, list);
+}
+
+/**
+ * Генерирует резолвер для модели. Учитывает список исключений и whiteList
+ *
+ * @param modelname string
+ * @returns void
+ */
+
+function addModelResolver(modelname) {
+  if (!sails.models[modelname]) return;
+  let modelName = sails.models[modelname].globalId;
+  if (!modelName) {
+    sails.log.error('graphql >>> Wrong Model Name :' + modelname);
+    return;
+  }
+
+  // Query resolver
+  if (whiteList[modelname].includes('query') && !blackList.includes(`${modelName}`)) {
+    models.add(modelname); // make schema Type for Model
+    const methodName = firstLetterToLowerCase(modelName)
+    let resolverQuery = {
+      def: `""" autogenerated """ ${methodName}(criteria: Json): [${modelName}]`,
+      fn: async function (parent, args, context) {
+
+        let criteria = args.criteria || {};
+        criteria = sanitizeCriteria(modelname, criteria);
+
+        // If model has User field need auth
+        if (sails.models[modelname].attributes.user) {
+          if (userAuth) {
+            let user = await userAuth(
+              context.connectionParams.authorization
+            );
+            if (user.id) {
+              criteria.user = user.id;
+            } else return null;
+          } else {
+            return null;
+          }
+        }
+
+        let query: any = { where: criteria};
+        //sorting
+        if (sails.models[modelname].attributes.order) {
+          query.sort = 'order ASC'
+        }
+
+        let result = await sails.models[modelname].find(query);
+
+        getEmitter().emit(`graphql-query-${modelname}`, result);
+
+        //workTime filter
+
+        if (sails.models[modelname].attributes.workTime) {
+          result = result.filter(record => {
+            if (!record.workTime) return true;
+            try {
+                return (WorkTimeValidator.isWorkNow({workTime: record.workTime})).workNow
+            } catch (error) {
+                sails.log.error("Graphql > helper > error: ",error)
+            }
+          })
+        }
+
+        result.forEach(item => {
+
+          getEmitter().emit(
+            `http-api:before-send-${modelname.toLowerCase()}`,
+            item
+          );
+        });
+
+        return result;
+      },
+    };
+    modelsResolvers.Query[methodName] = resolverQuery;
+  }
+    // Model fields resolvers
+    let resolvers = {};
+    // iterate separate resolvers in model (type])
+    Object.keys(sails.models[modelname].attributes).forEach((key) => {
+      if (key.includes("__")) return;
+      if (blackList.includes(`${modelName}.${key}`) || blackList.includes(`${key}`)) return;
+      if (typeof sails.models[modelname].attributes[key] === 'function') return;
+
+      if (sails.models[modelname].attributes[key].graphql) {
+        if (sails.models[modelname].attributes[key].graphql.public === false)
+          return;
+      }
+
+      let modelAttribute = sails.models[modelname].attributes[key];
+
+      if (modelAttribute.collection || modelAttribute.model) {
+        let modelRelationType = modelAttribute.collection
+          ? "collection"
+          : "model";
+
+        let relationKey =
+            modelAttribute.via !== undefined
+            ? modelAttribute.via
+            : "id";
+
+        let criteria = {};
+        criteria = sanitizeCriteria(modelAttribute[modelRelationType], criteria);
+
+        switch (modelRelationType) {
+          case "model":
+            resolvers[key] = async (parent, args, context) => {
+              criteria[relationKey] = parent[key];
+              let result = await sails.models[modelAttribute[modelRelationType]].findOne(criteria);
+
+              // TODO: this need only for support legacy patching (discount)
+              getEmitter().emit(
+                `http-api:before-send-${modelAttribute.model.toLowerCase()}`,
+                result
+              );
+
+              // celan if not work time
+              if (result && result.workTime && !WorkTimeValidator.isWorkNow({workTime: result.workTime}).workNow) {
+                result = null;
+              }
+            };
+            
+            return;
+          case "collection":
+            resolvers[key] = async (parent, args, context) => {
+
+
+              let subcriteria: any = {};
+
+              let subquery: any = { where: criteria};
+              //sorting
+              if (sails.models[modelname].attributes.order) {
+                subquery.sort = 'order ASC'
+              }
+
+              let result = (await sails.models[modelname].findOne({id: parent.id}).populate(key, subquery));
+              result = result ? result[key] : null;
+
+              // TODO: this need only for support legacy patching (discount)
+              if (result && result.length){
+                result.forEach(item => {
+                  getEmitter().emit(
+                    `http-api:before-send-${modelAttribute.collection.toLowerCase()}`,
+                    item
+                  );
+                });
+              }
+
+              if (sails.models[modelname].attributes.workTime && Array.isArray(result)) {
+                result = result.filter(record => {
+                  if (!record.workTime) return true
+                  try {
+                    return (WorkTimeValidator.isWorkNow({workTime: record.workTime})).workNow
+                  } catch (error) {
+                    sails.log.error("Graphql > helper > error: ",error)
+                  }
+                });
+              }
+              return result;
+            };
+
+            return;
+          default:
+            // empty
+            break;
+        }
+      }
+
+      resolvers[key] = async (parent, args, context) => {
+        return parent && parent[key];
+      };
+    });
+
+    console.log(modelName,resolvers)
+    modelsResolvers[modelName] = resolvers;
+
+
+  // Subscription resolver
+  if (!blackList.includes(`${modelName}`) && whiteList[modelname].includes('subscription')) {
+    models.add(modelname);
+    const methodName = `${firstLetterToLowerCase(modelName)}`;
+    let subscription = {
+      def: `""" Generated """ ${methodName}(criteria: Json): ${modelName}`,
+      fn: {
+        subscribe: withFilter(
+          (rootValue, args, context, info) =>
+            context.pubsub.asyncIterator(modelName),
+          async (payload, args, context, info) => {
+
+            // For User models
+            if (sails.models[modelname].attributes.user) {
+              if (userAuth) {
+                let user = await userAuth(
+                  context.connectionParams.authorization
+                );
+                if (user.id === payload.user){
+                  if (args.criteria) {
+                    checkCriteria(payload, args.criteria)
+                  } else {
+                    return true;
+                  }
+                };
+              } else {
+                return false;
+              }
+            }
+
+            return checkCriteria(payload, args.criteria)
+            
+            // Filter by waterline criteria
+            function checkCriteria(payload: any, criteria: any): boolean{
+
+              // For id's array
+              if (Array.isArray(criteria) ||  typeof criteria === "string"){
+                return (WLCriteria(payload, { where: { id: criteria }}).results).length > 0
+              }
+
+              // Where cause
+              if ( typeof criteria === 'object' && !Array.isArray(criteria) && criteria !== null ) {
+                return (WLCriteria(payload, { where: criteria }).results).length > 0
+              }
+            
+              return false
+            }
+
+          }
+        ),
+        resolve: (payload) => {
+          return payload;
+        },
+      },
+    };
+    // add publish in model
+    modelPublishExtend(modelname);
+    if (!modelsResolvers.Subscription) modelsResolvers.Subscription = {};
+    modelsResolvers.Subscription[methodName] = subscription;
+  }
+}
+
+/**
+ * Внутренняя функция используется при автогенерации резолверов
+ * Модифицирует модель. Добавляет рассылку сообщений при afterUpdate & afterCreate
+ *
+ * @param modelname
+ */
+function modelPublishExtend(modelname) {
+  let modelName = sails.models[modelname].globalId;
+
+  let afterCreate = sails.models[modelname].afterCreate;
+  sails.models[modelname].afterCreate = async function (values, cb ) {
+      await sails.models[modelname].publish(values.id);
+      if (afterCreate) {
+        afterCreate(values, cb);
+      } else {
+        cb();
+      }
+  };
+
+  let afterUpdate = sails.models[modelname].afterUpdate;
+  sails.models[modelname].afterUpdate = async function (values, cb ) {
+      await sails.models[modelname].publish(values.id);
+      if (afterUpdate) {
+        afterUpdate(values, cb);
+      } else {
+        cb();
+      }
+  };
+
+  let modelPublishExtendObj = {
+    publish: async function (id) {
+      let data = await sails.models[modelname].findOne(id);
+      // `http-api:request-${modelAttribute.collection.toLowerCase()}model-list`,
+
+      getEmitter().emit(`http-api:before-send-${modelname.toLowerCase()}`, data);
+      sails.graphql.pubsub.publish(modelName, data);
+    },
+  };
+
+  _.merge(sails.models[modelname], modelPublishExtendObj);
+}
+
+
+export default {
+  addModel,
+  addType,
+  addResolvers,
+  getSchema,
+
+  addToBlackList,
+  addCustomField,
+  addToReplaceList,
+  addAllSailsModels,
+  addDirResolvers,
+
+  addModelResolver,
+  setWhiteList
+}
+export {
+  addModel,
+  addType,
+  addResolvers,
+  getSchema,
+
+  addToBlackList,
+  addCustomField,
+  addToReplaceList,
+  addAllSailsModels,
+  addDirResolvers,
+
+  addModelResolver,
+  setWhiteList
+}
+
+interface Resolvers {
+  Query?: Resolver,
+  Mutation?: Resolver,
+  Subscription?: Resolver
+}
+interface Resolver {
+  [name: string]: {
+    def?: string,
+    fn?: Object,
+    subscribe?: Object,
+    resolve?: Object,
+    [x: string]: Object
+  }
+}

package/lib/initialize.d.ts

@@ -0,0 +1 @@
+export default function ToInitialize(): (cb: any) => any;

package/lib/initialize.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hookTools_1 = require("@webresto/core/libs/hookTools");
+const afterHook_1 = require("@webresto/graphql/lib/afterHook");
+function ToInitialize() {
+    /**
+     * List of hooks that required
+     */
+    const requiredHooks = [
+        'restocore'
+    ];
+    return function initialize(cb) {
+        /**
+         * AFTER OTHERS HOOKS
+         */
+        sails.log.info('>>> graphql hook - initialize');
+        hookTools_1.default.waitForHooks('graphql', requiredHooks, afterHook_1.default);
+        return cb();
+    };
+}
+exports.default = ToInitialize;
+;