docs: function extractBits(property) {
    let array = isArray(property) ? property : [property, property, null]
    let reply;
  
    if (!property) {
      let error = new Error(
        'Invalid property. Given\n  %o',
        inspect(property, {depth: 2})
      );
  
      return {
        fieldName: 'anErrorOccurred',
        modelName: 'anErrorOccurred',
        typeClass: null,
        getterMaker: function() { return () => error },
        setterMaker: function() { return (v) => undefined }
      }
    }
  
    //
    if (array.length === 3) {
      reply = {
        fieldName: array[0],
        modelName: array[1],
        typeClass: typeof array[2] === 'function' && array[2] || null
      }
    }
  
    //
    else if (array.length === 2) {
      reply = {
        fieldName: array[0],
        modelName: typeof array[1] === 'string'
          ? array[1]
          : array[0],
        typeClass: typeof array[1] === 'function' && array[1] || null
      }
    }
  
    //
    else {
      reply = {
        fieldName: array[0],
        modelName: array[0],
        typeClass: array[0]
      }
    }
  
    reply.getterMaker = function() {
      let { modelName, fieldName, typeClass } = reply;
  
      return function() {
        const thisClass = this.constructor
        const model = this[MODEL_KEY] || null
        let val
  
        if (!extendsFrom(thisClass, GQLBase)) {
          console.error(`${thisClass.name} is not derived from GQLBase`);
          return undefined
        }
  
        if (!thisClass.SCHEMA) {
          throw new Error(`
          All GQLBase extended classes should have a defined SCHEMA. Please
          manually define a static get SCHEMA() in your class or use the
          @Schema() decorator to do so.
          `)
        }
  
        if (typeClass) {
          // If the value of the model is already the type of class we expect
          // we do not need to do any processing and we can just grab it and
          // go.
          if (model[modelName] && extendsFrom(model[modelName], typeClass)) {
            val = model[modelName]
          }
  
          // Otherwise we need to return an instance of the determined typeClass
          // and pass that back instead; as requested.
          else {
            const results = SyntaxTree.findField(
              parse(this.constructor.SCHEMA),
              this.constructor.name,
              modelName
            )
            const { meta } = results || { meta: null };
  
            let args = [model[modelName], this.requestData];
  
            if (meta && !meta.nullable && !model) {
              throw new Error(`
                Using @Getters or @Properties decorators with a null or
                undefined model when the schema states that this field
                cannot be null.
  
                Type      : ${typeClass.name}
                Field (AST data)
                  name    : ${meta.name}
                  type    : ${meta.type}
                  nullable: ${meta.nullable}
                [getter]  : ${fieldName}
                [maps to] : ${modelName}
                [model  ] : ${model}
              `)
            }
  
            // If the following is true, it means that despite allowing nulls
            // for this field in the schema, we do have a valid model and should
            // proceed.
            if (model) {
              if (extractBits.DIRECT_TYPES.includes(typeClass.name)) {
                val = typeClass(...args)
              }
              else {
                val = new typeClass(...args)
              }
  
              if (typeClass.GQL_TYPE === GraphQLEnumType) { return val.value; }
            }
          }
        }
        else {
          val = model[modelName];
        }
  
        if (val === 'undefined' || val === undefined) {
          val = null;
        }
  
        return val;
      }
    }
  
    reply.setterMaker = function() {
      let { modelName } = reply;
      return function (value) {
        this[MODEL_KEY][modelName] = value;
      }
    }
  
    return reply;
  }