fix: concat of mixed and subtype (#444)

* fix: concat of mixed and subtype

* fix: concat with lazy

src/mixed.js

@@ -5,7 +5,7 @@ import toArray from 'lodash/toArray';
 import { mixed as locale } from './locale';
 import Condition from './Condition';
 import runValidations from './util/runValidations';
-import merge from './util/merge';
+import prependDeep from './util/prependDeep';
 import isSchema from './util/isSchema';
 import isAbsent from './util/isAbsent';
 import createValidation from './util/createValidation';
@@ -103,31 +103,29 @@ const proto = (SchemaType.prototype = {
  },
 
  concat(schema) {
- if (!schema) return this;
+ if (!schema || schema === this) return this;
 
  if (schema._type !== this._type && this._type !== 'mixed')
  throw new TypeError(
  `You cannot \`concat()\` schema's of different types: ${
  this._type
  } and ${schema._type}`,
  );
- var cloned = this.clone();
- var next = merge(this.clone(), schema.clone());
 
- // undefined isn't merged over, but is a valid value for default
+ var next = prependDeep(schema.clone(), this);
+
+ // new undefined default is overriden by old non-undefined one, revert
  if (has(schema, '_default')) next._default = schema._default;
 
- next.tests = cloned.tests;
- next._exclusive = cloned._exclusive;
+ next.tests = this.tests;
+ next._exclusive = this._exclusive;
 
  // manually add the new tests to ensure
  // the deduping logic is consistent
  schema.tests.forEach(fn => {
  next = next.test(fn.OPTIONS);
  });
 
- next._type = schema._type;
-
  return next;
  },
 

src/util/prependDeep.js

@@ -0,0 +1,27 @@
+import has from 'lodash/has';
+import isSchema from './isSchema';
+
+let isObject = obj => Object.prototype.toString.call(obj) === '[object Object]';
+
+export default function prependDeep(target, source) {
+ for (var key in source)
+ if (has(source, key)) {
+ var sourceVal = source[key],
+ targetVal = target[key];
+
+ if (targetVal === undefined) {
+ target[key] = sourceVal;
+ } else if (targetVal === sourceVal) {
+ continue;
+ } else if (isSchema(targetVal)) {
+ if (isSchema(sourceVal)) target[key] = sourceVal.concat(targetVal);
+ } else if (isObject(targetVal)) {
+ if (isObject(sourceVal))
+ target[key] = prependDeep(targetVal, sourceVal);
+ } else if (Array.isArray(targetVal)) {
+ if (Array.isArray(sourceVal)) target[key] = sourceVal.concat(targetVal);
+ }
+ }
+
+ return target;
+}

test/mixed.js

@@ -1,4 +1,15 @@
-import { array, mixed, string, number, object, ref, reach, bool } from '../src';
+import {
+ array,
+ mixed,
+ string,
+ number,
+ object,
+ ref,
+ reach,
+ bool,
+ ValidationError,
+} from '../src';
+
 let noop = () => {};
 
 function ensureSync(fn) {
@@ -585,6 +596,14 @@ describe('Mixed Types ', () => {
  }.should.not.throw(TypeError));
  });
 
+ it('concat should validate with mixed and other type', async function() {
+ let inst = mixed().concat(number());
+
+ await inst
+ .validate([])
+ .should.be.rejected(ValidationError, /should be a `number`/);
+ });
+
  it('concat should maintain undefined defaults', function() {
  let inst = string().default('hi');
 

test/yup.js

@@ -1,5 +1,5 @@
 import reach, { getIn } from '../src/util/reach';
-import merge from '../src/util/merge';
+import prependDeep from '../src/util/prependDeep';
 import { settled } from '../src/util/runValidations';
 
 import { object, array, string, lazy, number } from '../src';
@@ -36,11 +36,11 @@ describe('Yup', function() {
  ]);
  });
 
- it('should merge', function() {
- var a = { a: 1, b: 'hello', c: [1, 2, 3], d: { a: /hi/ }, e: { b: 5 } };
- var b = { a: 4, c: [4, 5, 3], d: { b: 'hello' }, f: { c: 5 }, g: null };
+ it('should prepend deeply', function() {
+ var a = { a: 4, c: [4, 5, 3], d: { b: 'hello' }, f: { c: 5 }, g: null };
+ var b = { a: 1, b: 'hello', c: [1, 2, 3], d: { a: /hi/ }, e: { b: 5 } };
 
- merge(a, b).should.deep.eql({
+ prependDeep(a, b).should.deep.eql({
  a: 4,
  b: 'hello',
  c: [1, 2, 3, 4, 5, 3],
@@ -54,6 +54,17 @@ describe('Yup', function() {
  });
  });
 
+ it('should not prepend needlesly', function() {
+ var schema = string();
+ var spy = sinon.spy(schema, 'concat');
+ var a = { schema };
+ var b = { schema };
+ var c = prependDeep(a, b);
+
+ c.schema.should.equal(schema);
+ spy.should.not.have.been.called();
+ });
+
  it('should getIn correctly', async () => {
  var num = number(),
  inst = object().shape({