fix(schema-analyser): handle references correctly when they can not be found (#830)

Author: SteveBunlon

src/adapters/mongoose.js

@@ -1,6 +1,5 @@
-const _ = require('lodash');
-const Interface = require('forest-express');
 const utils = require('../utils/schema');
+const Analyser = require('../utils/field-analyser');
 
 /* eslint-disable */
 function unflatten(data) {
@@ -25,288 +24,11 @@ function unflatten(data) {
 module.exports = async (model, opts) => {
   const fields = [];
   const paths = unflatten(model.schema.paths);
-  const { Mongoose } = opts;
-  // NOTICE: mongoose.base is used when opts.mongoose is not the default connection.
-  let schemaType;
-
-  function formatRef(ref) {
-    const referenceModel = utils.getReferenceModel(opts, ref);
-    if (referenceModel) {
-      return utils.getModelName(referenceModel);
-    }
-    Interface.logger.warn(`Cannot find the reference "${ref}" on the model "${model.modelName}".`);
-    return null;
-  }
-
-  function detectReference(fieldInfo) {
-    if (fieldInfo.options) {
-      if (fieldInfo.options.ref && fieldInfo.options.type) {
-        return `${formatRef(fieldInfo.options.ref)}._id`;
-      }
-      if (_.isArray(fieldInfo.options.type) && fieldInfo.options.type.length
-        && fieldInfo.options.type[0].ref && fieldInfo.options.type[0].type) {
-        return `${formatRef(fieldInfo.options.type[0].ref)}._id`;
-      }
-    }
-    return null;
-  }
-
-  function objectType(fieldsInfo, getType) {
-    const type = { fields: [] };
-
-    Object.keys(fieldsInfo).forEach((fieldName) => {
-      const fieldInfo = fieldsInfo[fieldName];
-      const field = {
-        field: fieldName,
-        type: getType(fieldName),
-      };
-
-      if (fieldName === '_id') {
-        field.isPrimaryKey = true;
-      }
-
-      if (!field.type) { return; }
-
-      const ref = detectReference(fieldInfo);
-      if (ref) { field.reference = ref; }
-
-      if (fieldInfo.enumValues && fieldInfo.enumValues.length) {
-        field.enums = fieldInfo.enumValues;
-      }
-
-      if (fieldInfo.enum
-        && Array.isArray(fieldInfo.enum)
-        && fieldInfo.enum.length) {
-        field.enums = fieldInfo.enum;
-      }
-
-      type.fields.push(field);
-    });
-
-    return type;
-  }
-
-  function getTypeFromNative(type) {
-    if (type instanceof Array) {
-      if (_.isEmpty(type)) {
-        return [null];
-      }
-      return [getTypeFromNative(type[0].type || type[0])];
-    }
-    if (_.isPlainObject(type)) {
-      if (_.isEmpty(type)) { return 'Json'; }
-
-      if (type.type) {
-        if (type.enum) {
-          // NOTICE: Detect enum values for Enums in subdocument arrays.
-          return 'Enum';
-        }
-        return getTypeFromNative(type.type);
-      }
-      return objectType(type, (key) => getTypeFromNative(type[key]));
-    }
-    if (_.isFunction(type) && type.name === 'ObjectId') {
-      return 'String';
-    }
-    if (type instanceof Mongoose.Schema) {
-      return schemaType(type);
-    }
-
-    switch (type) {
-      case String:
-        return 'String';
-      case Boolean:
-        return 'Boolean';
-      case Number:
-        return 'Number';
-      case Date:
-        return 'Date';
-      default:
-        return null;
-    }
-  }
-
-  function getTypeFromMongoose(fieldInfo) {
-    if (_.isPlainObject(fieldInfo) && !fieldInfo.path) {
-      // Deal with Object
-      return objectType(fieldInfo, (fieldName) => getTypeFromMongoose(fieldInfo[fieldName]));
-    }
-    if (fieldInfo.instance === 'Array') {
-      if (_.isEmpty(fieldInfo.options.type) && !_.isUndefined(fieldInfo.options.type)) {
-        return 'Json';
-      }
-
-      // Deal with Array
-      if (fieldInfo.caster.instance && (fieldInfo.caster.options.ref
-        || _.keys(fieldInfo.caster.options).length === 0)) {
-        return [getTypeFromMongoose(fieldInfo.caster)];
-      }
-      if (fieldInfo.options.type[0] instanceof Mongoose.Schema) {
-        // Schema
-        return [schemaType(fieldInfo.options.type[0])];
-      }
-
-      // NOTICE: Object with `type` reserved keyword.
-      //         See: https://mongoosejs.com/docs/schematypes.html#type-key
-      if (fieldInfo.options.type[0] instanceof Object
-        && fieldInfo.options.type[0].type
-        // NOTICE: Bypass for schemas like `[{ type: {type: String}, ... }]` where "type" is used
-        //         as property, and thus we are in the case of an array of embedded documents.
-        //         See: https://mongoosejs.com/docs/faq.html#type-key
-        && !fieldInfo.options.type[0].type.type) {
-        return [getTypeFromNative(fieldInfo.options.type[0])];
-      }
-
-      // Object
-      return [objectType(fieldInfo.options.type[0], (key) =>
-        getTypeFromNative(fieldInfo.options.type[0][key]))];
-    }
-    if (fieldInfo.enumValues && fieldInfo.enumValues.length) {
-      return 'Enum';
-    }
-    if (fieldInfo.instance === 'ObjectID') {
-      // Deal with ObjectID
-      return 'String';
-    }
-    if (fieldInfo.instance === 'Embedded') {
-      return objectType(fieldInfo.schema.obj, (fieldName) =>
-        getTypeFromNative(fieldInfo.schema.obj[fieldName]));
-    }
-    if (fieldInfo.instance === 'Mixed') {
-      // Deal with Mixed object
-
-      // NOTICE: Object and {} are detected as Json type as they don't have schema.
-      if (_.isEmpty(fieldInfo.options.type) && !_.isUndefined(fieldInfo.options.type)) {
-        return 'Json';
-      }
-      if (_.isEmpty(fieldInfo.options) && !_.isUndefined(fieldInfo.options)) {
-        return 'Json';
-      }
-
-      return null;
-    }
-    // Deal with primitive type
-    return fieldInfo.instance
-      || (fieldInfo.options && getTypeFromNative(fieldInfo.options.type))
-      || null;
-  }
-
-  schemaType = (type) => ({
-    fields: _.map(type.paths, (fieldType, fieldName) => {
-      const field = {
-        field: fieldName,
-        type: getTypeFromMongoose(fieldType),
-      };
-
-      if (fieldName === '_id') {
-        field.isPrimaryKey = true;
-      }
-
-      if (fieldType.enumValues && fieldType.enumValues.length) {
-        field.enums = fieldType.enumValues;
-      }
-
-      return field;
-    }),
-  });
-
-  function getRequired(fieldInfo) {
-    return fieldInfo.isRequired === true
-      || (
-        fieldInfo.path === '_id'
-        && !fieldInfo.options.auto
-        && fieldInfo.options.type !== Mongoose.ObjectId
-      );
-  }
-
-  function getValidations(fieldInfo) {
-    const validations = [];
-
-    if (fieldInfo.validators && fieldInfo.validators.length > 0) {
-      _.each(fieldInfo.validators, (validator) => {
-        if (validator.type === 'required') {
-          validations.push({
-            type: 'is present',
-          });
-        }
-
-        if (validator.type === 'minlength') {
-          validations.push({
-            type: 'is longer than',
-            value: validator.minlength,
-          });
-        }
-
-        if (validator.type === 'maxlength') {
-          validations.push({
-            type: 'is shorter than',
-            value: validator.maxlength,
-          });
-        }
-
-        if (validator.type === 'min') {
-          validations.push({
-            type: 'is greater than',
-            value: validator.min,
-          });
-        }
-
-        if (validator.type === 'max') {
-          validations.push({
-            type: 'is less than',
-            value: validator.max,
-          });
-        }
-      });
-    }
-
-    return validations;
-  }
-
-  function getFieldSchema(path) {
-    const fieldInfo = paths[path];
-
-    const schema = { field: path, type: getTypeFromMongoose(fieldInfo) };
-
-    const ref = detectReference(fieldInfo);
-    if (ref) { schema.reference = ref; }
-
-    if (fieldInfo.enumValues && fieldInfo.enumValues.length) {
-      schema.enums = fieldInfo.enumValues;
-    }
-
-    // NOTICE: Create enums from caster (for ['Enum'] type).
-    if (fieldInfo.caster && fieldInfo.caster.enumValues && fieldInfo.caster.enumValues.length) {
-      schema.enums = fieldInfo.caster.enumValues;
-    }
-
-    const isRequired = getRequired(fieldInfo);
-    if (isRequired) {
-      schema.isRequired = isRequired;
-    }
-
-    if (path === '_id') {
-      schema.isPrimaryKey = true;
-    }
-
-    if (fieldInfo.options && !_.isNull(fieldInfo.options.default)
-      && !_.isUndefined(fieldInfo.options.default)
-      && !_.isFunction(fieldInfo.options.default)) {
-      schema.defaultValue = fieldInfo.options.default;
-    }
-
-    schema.validations = getValidations(fieldInfo);
-
-    if (schema.validations.length === 0) {
-      delete schema.validations;
-    }
-
-    return schema;
-  }
+  const analyser = new Analyser(model, opts);
 
   Object.keys(paths).forEach(async (path) => {
     if (path === '__v') { return; }
-    const field = getFieldSchema(path);
+    const field = analyser.getFieldSchema(path, paths[path]);
     fields.push(field);
   });