@coderich/autograph 0.9.16 → 0.10.2

package/src/service/app.service.js

@@ -54,6 +54,11 @@ exports.stripObjectUndefineds = obj => Object.entries(obj).reduce((prev, [key, v
 exports.pushIt = (arr, it) => arr[arr.push(it) - 1];
 exports.toKeyObj = obj => exports.keyPaths(obj).reduce((prev, path) => Object.assign(prev, { [path]: _.get(obj, path) }), {});
 
+exports.getGQLReturnType = (returnType) => {
+  const typeMap = { array: /^\[.+\].?$/, connection: /.+Connection!?$/, number: /^(Int|Float)!?$/, scalar: /.*/ };
+  return Object.entries(typeMap).find(([type, pattern]) => returnType.match(pattern))[0];
+};
+
 exports.removeUndefinedDeep = (obj) => {
   return exports.unravelObject(exports.keyPaths(obj).reduce((prev, path) => {
     const value = _.get(obj, path);
@@ -90,7 +95,8 @@ exports.map = (mixed, fn) => {
   if (mixed == null) return mixed;
   const isArray = Array.isArray(mixed);
   const arr = isArray ? mixed : [mixed];
-  const results = arr.map((...args) => fn(...args));
+  // const results = arr.map((...args) => fn(...args));
+  const results = arr.map((el, i, a) => fn(el, isArray ? i : undefined, isArray ? a : undefined));
   return isArray ? results : results[0];
 };
 
@@ -99,32 +105,6 @@ exports.mapPromise = (mixed, fn) => {
   return Array.isArray(map) ? Promise.all(map) : Promise.resolve(map);
 };
 
-exports.castCmp = (type, value) => {
-  switch (type) {
-    case 'String': {
-      return `${value}`;
-    }
-    case 'Float': case 'Number': {
-      const num = Number(value);
-      if (!Number.isNaN(num)) return num;
-      return value;
-    }
-    case 'Int': {
-      const num = Number(value);
-      if (!Number.isNaN(num)) return parseInt(value, 10);
-      return value;
-    }
-    case 'Boolean': {
-      if (value === 'true') return true;
-      if (value === 'false') return false;
-      return value;
-    }
-    default: {
-      return value;
-    }
-  }
-};
-
 exports.objectContaining = (a, b) => {
   if (a === b) return true;
 
@@ -141,14 +121,6 @@ exports.objectContaining = (a, b) => {
   return exports.hashObject(a) === exports.hashObject(b);
 };
 
-exports.serialize = (field, value) => {
-  if (!exports.isPlainObject(value)) return value;
-  const model = field.getModelRef();
-  if (!model) return value;
-  const key = model.idKey();
-  return value[key];
-};
-
 /**
  * Transform an object with dot.notation keys into an expanded object.
  * eg. { 'user.name': 'richard' } => { user: { name: 'richard' } }
@@ -277,3 +249,52 @@ exports.resolveDataObject = (obj) => {
     }, {});
   });
 };
+
+exports.seek = (obj, paths, hint) => {
+  // We first do a normal get
+  const value = _.get(obj, paths);
+  if (!hint || value !== undefined) return value;
+
+  // Normalize paths & hint for traversal
+  const $paths = Array.isArray(paths) ? paths : paths.split('.');
+  const $hint = exports.unravelObject(hint);
+
+  // Traverse paths and get as close to the value as possible
+  const { currentValue, pathsToGo } = $paths.reduce((prev, path, i, arr) => {
+    if (prev.currentValue === undefined) return prev;
+    if (!Object.prototype.hasOwnProperty.call(prev.currentValue, path)) return prev;
+    prev.currentValue = prev.currentValue[path];
+    prev.pathsToGo = arr.slice(i + 1);
+    return prev;
+  }, { currentValue: obj, pathsToGo: $paths });
+
+  // Only if we hit an array can we continue
+  if (!Array.isArray(currentValue)) return undefined;
+
+  // If we got to the last segment we need the hint in order to verify
+  const lastPath = Boolean(pathsToGo.length === 1);
+  const arr = lastPath ? currentValue.filter(v => exports.objectContaining(v, $hint)) : currentValue;
+
+  // We keep going, recursive, till we find the first value
+  return arr.reduce((prev, v) => prev || exports.seek(v, pathsToGo, $hint), undefined);
+};
+
+exports.deseek = (shape, obj, paths, hint) => {
+  // Normalize paths
+  const $paths = (Array.isArray(paths) ? paths : paths.split('.')).map((path) => {
+    const item = shape.find(s => s.to === path); // Deserializing from unknown to expected
+    return item ? item.from : path;
+  });
+
+  // Normalize hint
+  const $hint = Object.entries(exports.toKeyObj(hint)).reduce((prev, [key, value]) => {
+    const segments = key.split('.').map((path) => {
+      const item = shape.find(s => s.to === path); // Deserializing from unknown to expected
+      return item ? item.from : path;
+    });
+
+    return Object.assign(prev, { [segments.join('.')]: value });
+  }, {});
+
+  return exports.seek(obj, $paths, $hint);
+};

package/src/service/decorator.service.js

@@ -1,275 +1,27 @@
-const { get, set, remove, merge } = require('lodash');
 const GraphqlFields = require('graphql-fields');
-const Boom = require('../core/Boom');
-const Query = require('../query/Query');
-const { createSystemEvent } = require('./event.service');
-const { guidToId, unrollGuid, ucFirst, getDeep, ensureArray, objectContaining } = require('./app.service');
-
-const findParentField = (name, embed, model) => {
-  const schema = model.getSchema();
-  const fieldName = ucFirst(embed.isArray() ? embed.getName().replace(/s$/, '') : embed.getName());
-  const parentModelName = name.substr(0, name.lastIndexOf(fieldName));
-  const parentModel = schema.getModel(parentModelName);
-  const field = model.getFields().find(f => f.getType() === parentModelName) || parentModel.getFields().find(f => f.getType() === model.getName());
-  if (!field) throw Boom.badData(`Unable to locate parent field: '${model.getName()} -> ${parentModelName}'`);
-  return field;
-};
-
-const findParentAndContainerCreate = (name, doc, input, model, embeds) => {
-  let parent = doc;
-
-  const container = embeds.reduce((prev, embed, i) => {
-    // If further nested; must find the correct container
-    if (i > 0) {
-      const subField = findParentField(name, embed, model);
-      prev = prev.find(el => `${el.id}` === `${input[subField]}`);
-    }
-
-    parent = prev;
-    return getDeep(prev, embed.getName());
-  }, doc);
-
-  return { parent, container };
-};
-
-const findParentAndContainerUpdate = (fieldPath, doc, id, embeds) => {
-  const data = embeds.map((embed, i, arr) => getDeep(doc, arr.slice(0, i + 1).join('.')));
-  const [tail, prev = tail, head = prev] = [data[0], data[data.length - 2], data[data.length - 1]];
-  const container = head.find(el => `${id}` === `${el.id}`);
-  const parent = head === prev ? doc : prev.find(p => p[fieldPath.split('.').pop()].find(el => `${id}` === `${el.id}`));
-  return { tail, parent, container };
-};
-
-const resolveQuery = (method, name, resolver, model, embeds = []) => {
-  const [base] = embeds;
-  const curr = embeds[embeds.length - 1];
-  const fieldPath = embeds.map(field => field.getName()).join('.');
 
+const resolveQuery = (method, name, resolver, model) => {
   return async (root, args, context, info) => {
-    const { autograph } = context;
-
-    // Embedded document handler
-    if (fieldPath.length) {
-      switch (method) {
-        case 'get': {
-          // Readjust the where clause
-          const where = get(args, 'where', {});
-          set(where, `${fieldPath}.id`, args.id);
-          set(args, 'where', where);
-
-          return resolver.query(context, base.getModel(), args, info).then(([result]) => {
-            const arr = ensureArray(getDeep(result, fieldPath, []));
-            return arr.find(el => `${el.id}` === `${args.id}`);
-          });
-        }
-        case 'find': {
-          // Readjust the where clause
-          const where = get(args, 'where', {});
-          const $where = set({}, `${fieldPath}`, where);
-          set(args, 'where', $where);
-
-          return resolver.query(context, base.getModel(), args, info).then((results) => {
-            const arr = results.map(result => ensureArray(getDeep(result, fieldPath, []))).flat();
-            return arr.filter(el => objectContaining(el, where));
-          });
-        }
-        case 'count': {
-          // Readjust the where clause
-          const where = get(args, 'where', {});
-          const $where = set({}, `${fieldPath}`, where);
-          set(args, 'where', $where);
-
-          return resolver.query(context, base.getModel(), args, info).then((results) => {
-            const arr = results.map(result => ensureArray(getDeep(result, fieldPath, []))).flat();
-            return arr.filter(el => objectContaining(el, where)).length;
-          });
-        }
-        case 'create': {
-          const field = findParentField(name, curr, model);
-          const path = fieldPath.split('.').slice(0, -1).concat('id').join('.');
-          const input = unrollGuid(autograph, model, args.input);
-          const meta = args.meta || {};
-          const id = guidToId(autograph, get(input, field.getName()));
-
-          // Get overall document
-          const where = { [path]: id };
-          const doc = await autograph.resolver.match(base.getModel()).where(where).one();
-          if (!doc) throw Boom.notFound(`${base.getModel().getName()} Not Found`);
-
-          // Get parent and container within document
-          const query = new Query({ resolver: autograph.resolver, model, input, where, meta, root: doc });
-          const { container } = findParentAndContainerCreate(name, doc, input, model, embeds);
-          model.appendDefaultFields(query, input);
-
-          return createSystemEvent('Mutation', { method: 'create', query }, async () => {
-            let $$input = ensureArray(input.$input || input);
-            $$input = await Promise.all($$input.map(el => model.appendCreateFields(el, true)));
-            container.push(...$$input);
-            const $update = { [base.getName()]: get(doc, base.getName()) };
-            return autograph.resolver.match(base.getModel()).id(doc.id).flags({ novalidate: true }).save($update).then(($doc) => {
-              return getDeep(doc, fieldPath).pop();
-            });
-          });
-        }
-        case 'update': {
-          // Get overall document
-          const id = guidToId(autograph, args.id);
-          const where = { [`${fieldPath}.id`]: id };
-          const meta = args.meta || {};
-          const input = unrollGuid(autograph, model, args.input || {});
-          const doc = await autograph.resolver.match(base.getModel()).where(where).one();
-          if (!doc) throw Boom.notFound(`${base.getModel().getName()} Not Found`);
-
-          // Get parent and container within document
-          const query = new Query({ resolver: autograph.resolver, model, input, where, meta, root: doc });
-          const { tail, container } = findParentAndContainerUpdate(fieldPath, doc, id, embeds);
-
-          return createSystemEvent('Mutation', { method: 'update', query }, async () => {
-            const $input = await model.appendUpdateFields(input);
-            merge(container, $input); // Must mutate object here
-            const $update = { [base.getName()]: tail };
-            doc[base.getName()] = tail; // Deficiency in how update works; must pass entire doc
-            return autograph.resolver.match(base.getModel()).id(doc.id).flags({ novalidate: true }).save($update).then(() => container);
-          });
-        }
-        case 'delete': {
-          const id = guidToId(autograph, args.id);
-          const where = { [`${fieldPath}.id`]: id };
-          const meta = args.meta || {};
-          const doc = await autograph.resolver.match(base.getModel()).where(where).one();
-          if (!doc) throw Boom.notFound(`${base.getModel()} Not Found`);
-
-          // Get parent and container within document
-          const query = new Query({ resolver: autograph.resolver, model, where, meta, root: doc });
-          const { tail, parent, container } = findParentAndContainerUpdate(fieldPath, doc, id, embeds);
-
-          return createSystemEvent('Mutation', { method: 'delete', query }, () => {
-            const key = fieldPath.split('.').pop();
-            remove(parent[key], el => `${el.id}` === `${id}`);
-            const $update = { [base.getName()]: tail };
-            doc[base.getName()] = tail; // Deficiency in how update works; must pass entire doc
-            return autograph.resolver.match(base.getModel()).id(doc.id).flags({ novalidate: true }).save($update).then(() => container);
-          });
-        }
-        default: {
-          return null;
-        }
-      }
-    }
+    const queryInfo = { fields: GraphqlFields(info, {}, { processArguments: true }) };
 
     switch (method) {
-      case 'get': return resolver.get(context, model, args, true, info);
+      case 'get': return resolver.get(context, model, args, true, queryInfo);
       case 'find': {
         return {
-          edges: () => resolver.query(context, model, args, info),
-          pageInfo: () => resolver.query(context, model, args, info),
-          count: () => resolver.count(context, model, args, info),
+          edges: () => resolver.query(context, model, args, queryInfo),
+          pageInfo: () => resolver.query(context, model, args, queryInfo),
+          count: () => resolver.count(context, model, args, queryInfo),
         };
       }
-      case 'count': return resolver.count(context, model, args, info);
-      case 'create': return resolver.create(context, model, args, { fields: GraphqlFields(info, {}, { processArguments: true }) });
-      case 'update': return resolver.update(context, model, args, { fields: GraphqlFields(info, {}, { processArguments: true }) });
-      case 'delete': return resolver.delete(context, model, args, { fields: GraphqlFields(info, {}, { processArguments: true }) });
+      case 'count': return resolver.count(context, model, args, queryInfo);
+      case 'create': return resolver.create(context, model, args, queryInfo);
+      case 'update': return resolver.update(context, model, args, queryInfo);
+      case 'delete': return resolver.delete(context, model, args, queryInfo);
       default: return null;
     }
   };
 };
 
-const makeEmbeddedAPI = (model, method, parent) => {
-  let gql = '';
-  const modelName = model.getName();
-  const fields = model.getEmbeddedFields().filter(field => field !== parent && field.isEmbeddedApi());
-
-  if (fields.length) {
-    fields.forEach((field) => {
-      const modelRef = field.getModelRef();
-      const fieldName = ucFirst(field.isArray() ? field.getName().replace(/s$/, '') : field.getName());
-      const name = `${modelName}${fieldName}`;
-
-      switch (method) {
-        case 'create': {
-          if (field.hasFieldScope('c')) gql += exports.makeCreateAPI(name, modelRef, field);
-          break;
-        }
-        case 'read': {
-          if (field.hasFieldScope('r')) gql += exports.makeReadAPI(name, modelRef, field);
-          break;
-        }
-        case 'update': {
-          if (field.hasFieldScope('u')) gql += exports.makeUpdateAPI(name, modelRef, field);
-          break;
-        }
-        case 'delete': {
-          if (field.hasFieldScope('d')) gql += exports.makeDeleteAPI(name, modelRef, field);
-          break;
-        }
-        default: {
-          throw new Error(`Unknown method '${method}'`);
-        }
-      }
-    });
-  }
-
-  return gql;
-};
-
-const makeEmbeddedResolver = (model, resolver, type, embeds = []) => {
-  const obj = {};
-
-  const modelName = model.getName();
-  const fields = model.getEmbeddedFields().filter(field => embeds.indexOf(field) === -1 && field.isEmbeddedApi());
-
-  fields.forEach((field) => {
-    const modelRef = field.getModelRef();
-    const fieldName = ucFirst(field.isArray() ? field.getName().replace(/s$/, '') : field.getName());
-    const name = `${modelName}${fieldName}`;
-
-    switch (type) {
-      case 'query': {
-        Object.assign(obj, exports.makeQueryResolver(name, modelRef, resolver, embeds.concat(field)));
-        break;
-      }
-      case 'mutation': {
-        Object.assign(obj, exports.makeMutationResolver(name, modelRef, resolver, embeds.concat(field)));
-        break;
-      }
-      default: {
-        throw new Error(`Unknown type '${type}'`);
-      }
-    }
-  });
-
-  return obj;
-};
-
-exports.makeInputSplice = (model, embed = false) => {
-  let gql = '';
-  const fields = model.getArrayFields().filter(field => field.hasGQLScope('c', 'u', 'd') && field.isSpliceable());
-
-  if (fields.length) {
-    gql += fields.map((field) => {
-      const embedded = field.isEmbedded() ? exports.makeInputSplice(field.getModelRef(), true) : '';
-
-      return `
-        ${embedded}
-        input ${model.getName()}${ucFirst(field.getName())}InputSplice {
-          with: ${field.getGQLType('InputWhere', { splice: true })}
-          put: ${field.getGQLType('InputUpdate', { splice: true })}
-          ${embedded.length ? `splice: ${field.getModelRef().getName()}InputSplice` : ''}
-        }
-      `;
-    }).join('\n\n');
-
-    gql += `
-      input ${model.getName()}InputSplice {
-        ${fields.map(field => `${field.getName()}: ${model.getName()}${ucFirst(field.getName())}InputSplice`)}
-      }
-    `;
-  }
-
-  return gql;
-};
-
 // APIs
 exports.makeCreateAPI = (name, model, parent) => {
   let gql = '';
@@ -279,8 +31,6 @@ exports.makeCreateAPI = (name, model, parent) => {
     gql += `create${name}(input: ${model.getName()}InputCreate! ${meta}): ${model.getName()}!`;
   }
 
-  gql += makeEmbeddedAPI(model, 'create', parent);
-
   return gql;
 };
 
@@ -303,8 +53,6 @@ exports.makeReadAPI = (name, model, parent) => {
     `;
   }
 
-  gql += makeEmbeddedAPI(model, 'read', parent);
-
   return gql;
 };
 
@@ -312,21 +60,10 @@ exports.makeUpdateAPI = (name, model, parent) => {
   let gql = '';
 
   if (model.hasGQLScope('u')) {
-    const spliceFields = model.getArrayFields().filter(field => field.hasGQLScope('c', 'u', 'd') && field.isSpliceable());
     const meta = model.getMeta() ? `meta: ${model.getMeta()}` : '';
-
-    gql += `
-      update${name}(
-        id: ID!
-        input: ${model.getName()}InputUpdate
-        # ${!spliceFields.length ? '' : `splice: ${model.getName()}InputSplice`}
-        ${meta}
-      ): ${model.getName()}!
-    `;
+    gql += `update${name}(id: ID! input: ${model.getName()}InputUpdate ${meta}): ${model.getName()}!`;
   }
 
-  gql += makeEmbeddedAPI(model, 'update', parent);
-
   return gql;
 };
 
@@ -338,8 +75,6 @@ exports.makeDeleteAPI = (name, model, parent) => {
     gql += `delete${name}(id: ID! ${meta}): ${model.getName()}!`;
   }
 
-  gql += makeEmbeddedAPI(model, 'delete', parent);
-
   return gql;
 };
 
@@ -357,25 +92,23 @@ exports.makeSubscriptionAPI = (name, model, parent) => {
 };
 
 // Resolvers
-exports.makeQueryResolver = (name, model, resolver, embeds = []) => {
+exports.makeQueryResolver = (name, model, resolver) => {
   const obj = {};
-  const [field] = embeds.slice(-1);
 
-  if ((!field || field.hasFieldScope('r')) && model.hasGQLScope('r')) {
-    obj[`get${name}`] = resolveQuery('get', name, resolver, model, embeds);
-    obj[`find${name}`] = resolveQuery('find', name, resolver, model, embeds);
+  if (model.hasGQLScope('r')) {
+    obj[`get${name}`] = resolveQuery('get', name, resolver, model);
+    obj[`find${name}`] = resolveQuery('find', name, resolver, model);
   }
 
-  return Object.assign(obj, makeEmbeddedResolver(model, resolver, 'query', embeds));
+  return obj;
 };
 
-exports.makeMutationResolver = (name, model, resolver, embeds = []) => {
+exports.makeMutationResolver = (name, model, resolver) => {
   const obj = {};
-  const [field] = embeds.slice(-1);
 
-  if ((!field || field.hasFieldScope('c')) && model.hasGQLScope('c')) obj[`create${name}`] = resolveQuery('create', name, resolver, model, embeds);
-  if ((!field || field.hasFieldScope('u')) && model.hasGQLScope('u')) obj[`update${name}`] = resolveQuery('update', name, resolver, model, embeds);
-  if ((!field || field.hasFieldScope('d')) && model.hasGQLScope('d')) obj[`delete${name}`] = resolveQuery('delete', name, resolver, model, embeds);
+  if (model.hasGQLScope('c')) obj[`create${name}`] = resolveQuery('create', name, resolver, model);
+  if (model.hasGQLScope('u')) obj[`update${name}`] = resolveQuery('update', name, resolver, model);
+  if (model.hasGQLScope('d')) obj[`delete${name}`] = resolveQuery('delete', name, resolver, model);
 
-  return Object.assign(obj, makeEmbeddedResolver(model, resolver, 'mutation', embeds));
+  return obj;
 };

package/src/service/event.service.js

@@ -1,59 +1,26 @@
-const QueryService = require('../query/QueryService');
 const EventEmitter = require('../core/EventEmitter');
-const { ensureArray, ucFirst } = require('./app.service');
+const { ucFirst } = require('./app.service');
 
 // Event emitters
 const eventEmitter = new EventEmitter().setMaxListeners(100);
-const internalEmitter = new EventEmitter().setMaxListeners(100);
 const systemEvent = new EventEmitter().setMaxListeners(100).on('system', async (event, next) => {
   const { type, data } = event;
-  await internalEmitter.emit(type, data);
   next(await eventEmitter.emit(type, data)); // Return result from user-defined middleware
 });
 
 //
 exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
   let event = mixed;
-  let middleware = () => Promise.resolve();
   const type = ucFirst(name);
 
   if (name !== 'Setup' && name !== 'Response') {
-    const { method, query } = mixed;
-    const { resolver, model, meta, doc, id, input, sort, merged, native, root, crud } = query.toObject();
-
-    event = {
-      context: resolver.getContext(),
-      key: `${method}${model}`,
-      resolver,
-      method,
-      crud,
-      model,
-      meta,
-      id,
-      input,
-      query,
-      doc,
-      merged,
-      root,
-    };
-
-    middleware = () => new Promise(async (resolve) => {
-      if (!native) {
-        const $where = await QueryService.resolveWhereClause(query);
-        query.match(model.serialize(query, $where, true));
-      }
-
-      if (sort) {
-        query.$sort(QueryService.resolveSortBy(query));
-      }
-
-      resolve();
-    });
+    const { query } = mixed;
+    event = query.toObject();
+    event.query = query;
   }
 
   return systemEvent.emit('system', { type: `pre${type}`, data: event }).then((result) => {
-    if (result !== undefined) return result; // Allowing middleware to dictate result
-    return middleware().then(thunk);
+    return (result !== undefined) ? result : thunk(); // Allowing middleware to dictate result
   }).then((result) => {
     event.result = result;
     if (event.crud === 'create') event.doc = event.query.toObject().doc;
@@ -66,44 +33,3 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
 };
 
 exports.eventEmitter = eventEmitter;
-exports.internalEmitter = internalEmitter;
-
-
-/**
- * Hook into the pre event only!
- *
- * Kick off system events for embedded fields
- */
-const eventHandler = (event) => {
-  const { model, input, method, doc = input, query } = event;
-
-  return Promise.all(model.getEmbeddedFields().map((field) => {
-    return new Promise((resolve, reject) => {
-      if (Object.prototype.hasOwnProperty.call(input || {}, field.getName())) {
-        let i = 0;
-        const value = input[field.getName()];
-        const values = ensureArray(value).filter(el => el != null);
-        const newModel = field.getModelRef();
-
-        if (values.length) {
-          values.forEach((val) => {
-            const clone = query.clone().model(newModel).input(val).doc(doc);
-            exports.createSystemEvent('Mutation', { method, query: clone }, () => {
-              if (++i >= values.length) resolve();
-            }).catch(e => reject(e));
-            // const newEvent = { parent: doc, key: `${method}${field}`, method, model: newModel, resolver, query: new Query(resolver, newModel, { meta }), input: val };
-            // exports.createSystemEvent('Mutation', newEvent, () => {
-            //   if (++i >= values.length) resolve();
-            // }).catch(e => reject(e));
-          });
-        } else {
-          resolve();
-        }
-      } else {
-        resolve();
-      }
-    });
-  }));
-};
-
-internalEmitter.on('preMutation', async (event, next) => eventHandler(event).then(next)); // Only preMutation!

package/src/service/graphql.service.js

@@ -1,7 +1,5 @@
 const { get } = require('lodash');
 const { Kind, parse, print } = require('graphql');
-const { validate } = require('graphql/validation');
-const { makeExecutableSchema } = require('graphql-tools');
 
 //
 const mergePairs = [
@@ -81,13 +79,6 @@ exports.mergeASTArray = (arr) => {
   }, []).filter(el => !el.deleteFlag);
 };
 
-exports.validateSchema = (ast) => {
-  const errs = validate(makeExecutableSchema(ast), ast.typeDefs).filter(({ message }) => message.indexOf('not executable') === -1).map(({ message }) => message);
-  if (errs.length) throw new Error(errs.join('\n'));
-};
-
-exports.makeExecutableSchema = makeExecutableSchema;
-
 exports.toAST = (a) => {
   if (typeof a === 'string') return parse(a);
   if (Array.isArray(a)) return parse(a.map(e => exports.toGQL(e)).join('\n\n'));

package/src/service/schema.service.js

@@ -54,11 +54,13 @@ exports.getSchemaData = (schema) => {
 exports.identifyOnDeletes = (models, parentModel) => {
   return models.reduce((prev, model) => {
     model.getOnDeleteFields().forEach((field) => {
-      if (`${field.getModelRef()}` === `${parentModel}`) {
+      const { modelRef, isArray } = field.toObject();
+
+      if (`${modelRef}` === `${parentModel}`) {
         if (model.isEntity()) {
-          prev.push({ model, field, isArray: field.isArray(), op: field.getOnDelete() });
+          prev.push({ model, field, isArray, op: field.getOnDelete() });
         } else {
-          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray: field.isArray(), op: field.getOnDelete() })));
+          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray, op: field.getOnDelete() })));
         }
       }
     });