Refactor everything - include typeError messaging as a validation err…

…or, include transforms in ast, include funky validators (negate, serial, oneOfType) in ast

.eslintrc.js

@@ -14,6 +14,11 @@ module.exports = {
       node: {
         paths: ['./src'],
       },
+      alias: {
+        map: [
+          ['@zuze/schema','./src']
+        ]
+      }
     }
   },
   extends: [
@@ -38,7 +43,9 @@ module.exports = {
     'import/namespace': 0,
     'import/no-self-import': 2,
     'import/first': 2,
-    'import/order': 2,
+    'import/order': ['error',{
+      'newlines-between':'never'
+    }],
     'import/no-named-as-default': 0
   },
   overrides: [

jest.config.js

@@ -1,4 +1,7 @@
 module.exports = {
+  moduleNameMapper: {
+    '@zuze/schema': '<rootDir>/src',
+  },
   coverageThreshold: {
     global: {
       branches: 90,

package.json

@@ -4,6 +4,7 @@
   "description": "Composable validation schema, inspired by yup/joi",
   "main": "build/cjs/index.js",
   "module": "build/esm/index.js",
+  "sideEffects": false,
   "files": [
     "build"
   ],
@@ -42,6 +43,7 @@
     "coveralls": "^3.0.9",
     "eslint": "^6.4.0",
     "eslint-config-prettier": "^6.3.0",
+    "eslint-import-resolver-alias": "^1.1.2",
     "eslint-plugin-import": "^2.18.2",
     "eslint-plugin-jest": "^22.17.0",
     "eslint-plugin-prettier": "^3.1.0",

src/ast/astToFn.js

@@ -0,0 +1,15 @@
+const processor = (fn, ...args) => fn(...args);
+
+export default (property, source, err, process = processor) => (
+  ast,
+  options
+) => {
+  const [name, ...args] = Array.isArray(ast) ? ast : [ast];
+  const userDefined = options[property][name];
+  const fn = userDefined || source[name];
+  if (!fn) throw new Error(err(name));
+
+  // userDefined transforms/validators must always
+  // be a function that accepts options and returns a transform/validator factory
+  return process(userDefined ? fn(options) : fn, ...args);
+};

src/ast/createSchema.js

@@ -6,10 +6,25 @@ import array from '../array';
 import string from '../string';
 import mixed from '../mixed';
 import { condition } from '../conditions';
-import { createValidators } from './createValidator';
+import { createValidators } from './createValidators';
+import { createTransforms } from './createTransforms';
+import * as astTransforms from './transforms';
+import * as astValidators from './validators';
 
 const schemas = { object, number, boolean, date, array, string, mixed };
 
+const defaults = (options = {}) => ({
+  ...options,
+  transforms: {
+    ...astTransforms,
+    ...(options.transforms || {}),
+  },
+  validators: {
+    ...astValidators,
+    ...(options.validators || {}),
+  },
+});
+
 const make = (type, def, options = {}) => {
   const use = type || 'mixed';
   if (!schemas[use]) throw new Error(`Can't create schema ${type}`);
@@ -24,14 +39,29 @@ export const createSchemas = (defs, options) =>
   (Array.isArray(defs) ? defs : [defs]).map(d => createSchema(d, options));
 
 export const createSchema = (
-  { schema, tests = [], default: def, meta, label, shape, of, conditions },
+  {
+    schema,
+    tests = [],
+    transforms = [],
+    default: def,
+    meta,
+    typeError,
+    label,
+    shape,
+    of,
+    nullable,
+    conditions,
+  },
   options
-) =>
-  make(
+) => {
+  options = defaults(options);
+  return make(
     schema,
     {
       default: () => def,
-      label,
+      label: () => label,
+      nullable,
+      typeError,
       condition: conditions ? conditions.map(condition) : undefined,
       shape: shape
         ? Object.entries(shape).reduce(
@@ -45,6 +75,8 @@ export const createSchema = (
       of: of ? createSchema(of, options) : undefined,
       meta,
       test: createValidators(tests, options),
+      transform: createTransforms(transforms, options),
     },
     options
   );
+};

src/ast/createTransforms.js

@@ -0,0 +1,11 @@
+import * as transforms from '../transforms';
+import astToFn from './astToFn';
+
+const processor = astToFn(
+  'transforms',
+  transforms,
+  name => `No transform found for ${name}`
+);
+
+export const createTransforms = (ast, options) =>
+  ast.map(v => processor(v, options));

src/ast/createValidators.js

@@ -0,0 +1,15 @@
+import * as validators from '../validators';
+import { recursivelyConvertRefs } from './utils';
+import astToFn from './astToFn';
+
+const processor = astToFn(
+  'validators',
+  validators,
+  name => `No validator found for ${name}`,
+  (fn, ...args) => fn(...recursivelyConvertRefs(...args))
+);
+
+export const createValidators = (ast, options) =>
+  ast.map(v => createValidator(v, options));
+
+export const createValidator = (ast, options) => processor(ast, options);

src/ast/index.js

@@ -1,3 +1,2 @@
 export { default as matches } from './matches';
 export { createSchemas, createSchema } from './createSchema';
-export { createValidators, createValidator } from './createValidator';

src/ast/transforms/index.js

@@ -0,0 +1,3 @@
+// these transforms require special handling in ast-land
+export { default as reject } from './reject';
+export { default as unique } from './unique';

src/ast/transforms/reject.js

@@ -0,0 +1,4 @@
+import matches from '../matches';
+
+export default options => where => value =>
+  Array.isArray(value) ? value.filter(v => !matches(where, v, options)) : value;

src/ast/transforms/unique.js

@@ -0,0 +1,11 @@
+import { getter } from 'property-expr';
+const def = (a, b) => b === a;
+
+const createBy = using =>
+  using ? (a, b) => getter(using, true)(a) === getter(using, true)(b) : def;
+
+export default () => by => value => {
+  if (!Array.isArray(value)) return value;
+  const fn = createBy(by);
+  return value.filter((a, idx, arr) => arr.findIndex(b => fn(a, b)) === idx);
+};

src/ast/validators/index.js

@@ -0,0 +1,4 @@
+// these validators require special handling in ast-land
+export { default as negate } from './negate';
+export { default as oneOfType } from './oneOfType';
+export { default as serial } from './serial';

src/ast/validators/negate.js

@@ -0,0 +1,4 @@
+import { negate } from '../../validators';
+import { createValidator } from '../createValidators';
+
+export default options => def => negate(createValidator(def, options));

src/ast/validators/oneOfType.js

@@ -0,0 +1,5 @@
+import { oneOfType } from '../../validators';
+import { createSchema } from '../createSchema';
+
+export default options => types =>
+  oneOfType(types.map(t => createSchema(t, options)));

src/ast/validators/serial.js

@@ -0,0 +1,5 @@
+import { serial } from '../../validators';
+import { createValidator } from '../createValidators';
+
+export default options => defs =>
+  serial(...defs.map(d => createValidator(d, options)));

src/cast.js

@@ -2,48 +2,56 @@ import { defaults } from './utils';
 import resolve from './resolve';
 import castInner from './cast.inner';
 
-const check = (value, { typeCheck, type }, { assert }) => {
-  if (value !== undefined && assert && typeCheck && !typeCheck(value))
+const check = (
+  value,
+  { typeCheck, type, nullable, label },
+  { assert, path }
+) => {
+  if (!assert) return value;
+
+  if (value === null) {
+    if (nullable) return value;
+    throw new TypeError(
+      `null given for non-nullable schema ${label || type} ${
+        path ? `at ${path}` : ``
+      }`
+    );
+  }
+
+  if (value !== undefined && typeCheck && !typeCheck(value))
     throw new TypeError(
       `cast value of ${value} is not a valid type for schema ${type}`
     );
+
+  return value;
 };
 
 const cast = (schema, value, options) => {
   options = defaults(options);
   const fork = resolve(schema, { ...options, value });
   if (fork !== schema) return cast(fork, value, options);
 
-  const { strict, assert, path } = options;
-  const { transform, inner, default: def, nullable, label, type } = schema;
-
-  // nullable check
-  if (value === null) {
-    if (nullable) return value;
-    if (assert)
-      throw new Error(
-        `null given for non-nullable schema ${label || type} ${
-          path ? `at ${path}` : ``
-        }`
-      );
-  }
-
-  const innerSchema = inner && inner(schema);
-  value = innerSchema ? castInner(innerSchema, schema, value, options) : value;
+  const { strict } = options;
+  const { transform, inner, default: def } = schema;
 
-  const final =
+  value = check(
+    // transforms are ignored when value is undefined or in strict mode
     value === undefined || strict
       ? value
       : transform.reduce(
           (acc, fn) => fn(acc, value, { schema, options }),
           value
-        );
-
-  // check one more time
-  return (
-    check(final, schema, options),
-    final !== undefined ? final : typeof def === 'function' ? def() : def
+        ),
+    schema,
+    options
   );
+
+  const innerSchema = inner && inner(schema);
+  const final = innerSchema
+    ? castInner(innerSchema, schema, value, options)
+    : value;
+
+  return final !== undefined ? final : typeof def === 'function' ? def() : def;
 };
 
 export default cast;

src/index.js

@@ -27,7 +27,7 @@ export { default as lazy } from './lazy';
 export { default as ref, isRef } from './ref';
 export { default as conditional } from './conditional';
 export * from './validators';
-export * from './conditions';
+export { when, conditions, condition } from './conditions';
 export * from './without';
 export {
   warnings,
@@ -38,4 +38,5 @@ export {
   nullable,
   meta,
   errors,
+  typeError,
 } from './utils';

src/transforms/index.js

@@ -1,4 +1,4 @@
-export { default as string } from './string';
+export { default as string, trim, uppercase, lowercase } from './string';
 export { default as boolean } from './boolean';
 export { default as date } from './date';
 export { default as number } from './number';
@@ -11,5 +11,5 @@ export {
   stripKeys,
   stripUnknown,
 } from './object';
-export { default as array, compact, unique } from './array';
+export { default as array, compact, unique, exclude, only } from './array';
 export * from './utils';

src/transforms/string.js

@@ -1,2 +1,7 @@
 // nullables and undefined's will never get pased to this function
 export default v => v.toString();
+
+export const trim = () => v => v && v.trim();
+export const strip = () => v => v && v.replace(/\s/g);
+export const uppercase = () => v => v && v.toUpperCase();
+export const lowercase = () => v => v && v.toLowerCase();

src/utils/definition.js

@@ -6,6 +6,7 @@ export const isSchema = ({ __isSchema } = {}) => !!__isSchema;
 
 export default ({
   type,
+  typeError,
   typeCheck,
   test = [],
   transform = [],
@@ -21,6 +22,7 @@ export default ({
   typeCheck: typeCheck ? typeCheck : () => true,
   type: type || MIXED,
   test,
+  typeError,
   transform,
   condition,
   meta,
@@ -85,6 +87,7 @@ export const merge = (def, ...defs) =>
     (acc, def) => ({
       __isSchema: true,
       ...mergeTypes(def, acc),
+      typeError: acc.typeError || def.typeError,
       test: filterValidators(filterSame(acc.test, def.test)),
       transform: filterSame(acc.transform, def.transform),
       condition: filterSame(acc.condition, def.condition),

src/utils/errors.js

@@ -1,14 +1,23 @@
 export default (validationError, multiple = false) =>
   validationError
-    ? validationError.inner.reduce(
-        (acc, { path, message }) => ({
-          ...acc,
-          [path]: multiple
-            ? [...(acc[path] || []), message]
-            : acc.path
-            ? acc.path
-            : message,
-        }),
+    ? Object.entries(
+        validationError.inner.reduce(
+          (acc, { path, message }) => ({
+            ...acc,
+            [path]: multiple
+              ? [...(acc[path] || []), message]
+              : acc.path
+              ? acc.path
+              : message,
+          }),
+          {}
+        )
+      ).reduce(
+        // if we are getting errors from something with a non-inner
+        // schema then just return the errors, otherwise return a map
+        // of the errors by path
+        (acc, [path, errs]) =>
+          path === 'undefined' ? errs : { ...acc, [path]: errs },
         {}
       )
     : {};