feat: make schema.type and array.innerType public API's

Also simplify reach/getIn logic

Author: jquense

src/array.js

@@ -17,6 +17,7 @@ function ArraySchema(type) {
   // `undefined` specifically means uninitialized, as opposed to
   // "no subtype"
   this._subType = undefined;
+  this.innerType = undefined;
 
   this.withMutation(() => {
     this.transform(function(values) {
@@ -43,11 +44,11 @@ inherits(ArraySchema, MixedSchema, {
     const value = MixedSchema.prototype._cast.call(this, _value, _opts);
 
     //should ignore nulls here
-    if (!this._typeCheck(value) || !this._subType) return value;
+    if (!this._typeCheck(value) || !this.innerType) return value;
 
     let isChanged = false;
     const castArray = value.map((v, idx) => {
-      const castElement = this._subType.cast(v, {
+      const castElement = this.innerType.cast(v, {
         ..._opts,
         path: makePath`${_opts.path}[${idx}]`,
       });
@@ -65,7 +66,7 @@ inherits(ArraySchema, MixedSchema, {
     let errors = [];
     let sync = options.sync;
     let path = options.path;
-    let subType = this._subType;
+    let innerType = this.innerType;
     let endEarly = this._option('abortEarly', options);
     let recursive = this._option('recursive', options);
 
@@ -76,7 +77,7 @@ inherits(ArraySchema, MixedSchema, {
       .call(this, _value, options)
       .catch(propagateErrors(endEarly, errors))
       .then(value => {
-        if (!recursive || !subType || !this._typeCheck(value)) {
+        if (!recursive || !innerType || !this._typeCheck(value)) {
           if (errors.length) throw errors[0];
           return value;
         }
@@ -95,7 +96,7 @@ inherits(ArraySchema, MixedSchema, {
             originalValue: originalValue[idx],
           };
 
-          if (subType.validate) return subType.validate(item, innerOptions);
+          if (innerType.validate) return innerType.validate(item, innerOptions);
 
           return true;
         });
@@ -126,6 +127,7 @@ inherits(ArraySchema, MixedSchema, {
       );
 
     next._subType = schema;
+    next.innerType = schema;
 
     return next;
   },
@@ -175,7 +177,7 @@ inherits(ArraySchema, MixedSchema, {
 
   describe() {
     let base = MixedSchema.prototype.describe.call(this);
-    if (this._subType) base.innerType = this._subType.describe();
+    if (this.innerType) base.innerType = this.innerType.describe();
     return base;
   },
 });

src/mixed.js

@@ -72,6 +72,8 @@ export default function SchemaType(options = {}) {
 
   if (has(options, 'default')) this._defaultDefault = options.default;
 
+  this.type = options.type || 'mixed';
+  // TODO: remove
   this._type = options.type || 'mixed';
 }
 
@@ -117,9 +119,7 @@ const proto = (SchemaType.prototype = {
 
     if (schema._type !== this._type && this._type !== 'mixed')
       throw new TypeError(
-        `You cannot \`concat()\` schema's of different types: ${
-          this._type
-        } and ${schema._type}`,
+        `You cannot \`concat()\` schema's of different types: ${this._type} and ${schema._type}`,
       );
 
     var next = prependDeep(schema.clone(), this);

src/util/reach.js

@@ -1,65 +1,50 @@
 import { forEach } from 'property-expr';
-import has from 'lodash/has';
 
 let trim = part => part.substr(0, part.length - 1).substr(1);
 
-export function getIn(schema, path, value, context) {
+export function getIn(schema, path, value, context = value) {
   let parent, lastPart, lastPartDebug;
 
-  // if only one "value" arg then use it for both
-  context = context || value;
+  // root path: ''
+  if (!path) return { parent, parentPath: path, schema };
 
-  if (!path)
-    return {
-      parent,
-      parentPath: path,
-      schema,
-    };
-
-  // I no longer remember why this is so complicated
-  forEach(path, (_part, isBracket, isArray, partIdx, parts) => {
-    let isLast = partIdx === parts.length - 1;
+  forEach(path, (_part, isBracket, isArray) => {
     let part = isBracket ? trim(_part) : _part;
 
-    if (isArray || has(schema, '_subType')) {
-      // we skipped an array: foo[].bar
-      let idx = isArray ? parseInt(part, 10) : 0;
-
-      schema = schema.resolve({ context, parent, value })._subType;
+    schema = schema.resolve({ context, parent, value });
 
-      if (value) {
-        if (isArray && idx >= value.length) {
-          throw new Error(
-            `Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. ` +
-              `because there is no value at that index. `,
-          );
-        }
+    if (schema.innerType) {
+      let idx = isArray ? parseInt(part, 10) : 0;
 
-        if (isLast) {
-          parent = value;
-          lastPart = part;
-          lastPartDebug = isBracket ? '[' + _part + ']' : '.' + _part;
-        }
-        value = value[idx];
+      if (value && idx >= value.length) {
+        throw new Error(
+          `Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. ` +
+            `because there is no value at that index. `,
+        );
       }
+      parent = value;
+      value = value && value[idx];
+      schema = schema.innerType;
     }
 
+    // sometimes the array index part of a path doesn't exist: "nested.arr.child"
+    // in these cases the current part is the next schema and should be processed
+    // in this iteration. For cases where the index signature is included this
+    // check will fail and we'll handle the `child` part on the next iteration like normal
     if (!isArray) {
-      schema = schema.resolve({ context, parent, value });
-
-      if (!has(schema, 'fields') || !has(schema.fields, part))
+      if (!schema.fields || !schema.fields[part])
         throw new Error(
           `The schema does not contain the path: ${path}. ` +
             `(failed at: ${lastPartDebug} which is a type: "${schema._type}")`,
         );
 
-      schema = schema.fields[part];
-
       parent = value;
       value = value && value[part];
-      lastPart = part;
-      lastPartDebug = isBracket ? '[' + _part + ']' : '.' + _part;
+      schema = schema.fields[part];
     }
+
+    lastPart = part;
+    lastPartDebug = isBracket ? '[' + _part + ']' : '.' + _part;
   });
 
   return { schema, parent, parentPath: lastPart };

test/yup.js

@@ -107,7 +107,6 @@ describe('Yup', function() {
 
     const { schema, parent, parentPath } = getIn(inst, 'nested.arr[1]', value);
 
-    console.log(parentPath);
     expect(schema).to.equal(shape);
     expect(parentPath).to.equal('1');
     expect(parent).to.equal(value.nested.arr);
@@ -127,14 +126,14 @@ describe('Yup', function() {
 
     reach(inst, '').should.equal(inst);
 
-    reach(inst, 'nested.arr.num').should.equal(num);
+    reach(inst, 'nested.arr[0].num').should.equal(num);
     reach(inst, 'nested.arr[].num').should.equal(num);
     reach(inst, 'nested.arr[1].num').should.equal(num);
     reach(inst, 'nested.arr[1]').should.equal(shape);
 
     reach(inst, 'nested["arr"][1].num').should.not.equal(number());
 
-    let valid = await reach(inst, 'nested.arr[].num').isValid(5);
+    let valid = await reach(inst, 'nested.arr[0].num').isValid(5);
     valid.should.equal(true);
   });