feat(renderer): add function for collecting all validates from schema

Author: rvsia

packages/react-form-renderer/src/get-validates/get-validates.d.ts

@@ -0,0 +1,12 @@
+import { Schema, AnyObject, ComponentMapper } from "../common-types";
+import { ActionMapper } from "../form-renderer";
+
+export interface GetValidatesOptions {
+    values: AnyObject;
+    componentMapper: ComponentMapper;
+    actionMapper: ActionMapper;
+}
+
+declare function getValidates(schema: Schema, options: GetValidatesOptions, validations?: AnyObject): AnyObject;
+
+export default getValidates;

packages/react-form-renderer/src/get-validates/get-validates.js

@@ -0,0 +1,51 @@
+import get from 'lodash/get';
+
+import prepareComponentProps from '../prepare-component-props';
+
+const getValidates = (schema, { componentMapper, actionMapper, values }, validations = {}) => {
+  if (Array.isArray(schema)) {
+    schema.map((field) => getValidates(field, { componentMapper, actionMapper, values }, validations));
+  } else {
+    if (schema.component) {
+      let validate;
+
+      const { componentProps, overrideProps, mergedResolveProps } = prepareComponentProps({
+        component: schema.component,
+        rest: schema,
+        componentMapper,
+        actionMapper
+      });
+
+      let resolveProps = mergedResolveProps || overrideProps.resolveProps || componentProps.resolveProps;
+
+      // fake form state with only values
+      if (resolveProps) {
+        const { validate: resolvePropsValidate } = resolveProps(
+          schema,
+          { input: { value: get(values, schema.name) }, meta: {} },
+          { getState: () => ({ values }) }
+        );
+
+        validate = resolvePropsValidate;
+      }
+
+      validate = validate || overrideProps.validate || componentProps.validate;
+
+      if (validate) {
+        if (validations[schema.name]) {
+          validations[schema.name].push(validate);
+        } else {
+          validations[schema.name] = [validate];
+        }
+      }
+    }
+
+    if (schema.fields) {
+      getValidates(schema.fields, { componentMapper, actionMapper, values }, validations);
+    }
+  }
+
+  return validations;
+};
+
+export default getValidates;

packages/react-form-renderer/src/get-validates/index.d.ts

@@ -0,0 +1 @@
+export { default } from './get-validates';

packages/react-form-renderer/src/get-validates/index.js

@@ -0,0 +1 @@
+export { default } from './get-validates';

packages/react-form-renderer/src/tests/validation/get-validates.test.js

@@ -0,0 +1,83 @@
+import getValidates from '../../get-validates';
+
+describe('getValidates', () => {
+  const noop = () => {};
+
+  it('returns all the validates from the schema', () => {
+    const values = { x: 'value-of-x' };
+
+    const componentMapper = {
+      default: noop,
+      complexResolve: {
+        component: noop,
+        resolveProps: () => ({
+          validate: [{ type: 'complexResolve' }]
+        })
+      },
+      componentDefault: {
+        component: noop,
+        validate: [{ type: 'componentDefault' }]
+      },
+      componentActions: {
+        component: noop,
+        actions: {
+          validate: ['componentAction']
+        }
+      },
+      componentActionsResolve: {
+        component: noop,
+        actions: {
+          resolveProps: ['returnValidate']
+        }
+      }
+    };
+
+    const schema = {
+      fields: [
+        { name: 'no-validate' },
+        { name: 'no-validate-1', component: 'default' },
+        { name: 'simple', component: 'default', validate: [{ type: 'simple' }] },
+        { name: 'double', component: 'default', validate: [{ type: 'double-1' }] },
+        { name: 'double', component: 'default', validate: [{ type: 'double-2' }] },
+        { fields: [{ name: 'simple-2', component: 'default', validate: [{ type: 'simple-2' }] }] },
+        { name: 'component-default', component: 'componentDefault' },
+        { name: 'component-default-override', component: 'componentDefault', validate: [{ type: 'override' }] },
+        { name: 'component-actions', component: 'componentActions' },
+        { name: 'component-actions-resolve', component: 'componentActionsResolve' },
+        { name: 'complex-resolve', component: 'complexResolve' },
+        { name: 'simple-resolve', component: 'default', resolveProps: () => ({ validate: [{ type: 'from-resolve-props' }] }) },
+        { name: 'x', component: 'componentDefault', resolveProps: (_props, { input: { value } }) => ({ validate: [{ type: value }] }) },
+        {
+          name: 'xx',
+          component: 'componentDefault',
+          resolveProps: (_props, _inputMeta, { getState }) => ({ validate: [{ type: getState().values['x'] }] })
+        }
+      ]
+    };
+
+    const actionMapper = {
+      componentAction: () => [{ type: 'from-action' }],
+      returnValidate: () => () => ({ validate: [{ type: 'actions>resolveProps' }] })
+    };
+
+    expect(
+      getValidates(schema, {
+        componentMapper,
+        actionMapper,
+        values
+      })
+    ).toEqual({
+      'complex-resolve': [[{ type: 'complexResolve' }]],
+      'component-actions': [[{ type: 'from-action' }]],
+      'component-default': [[{ type: 'componentDefault' }]],
+      'component-default-override': [[{ type: 'override' }]],
+      double: [[{ type: 'double-1' }], [{ type: 'double-2' }]],
+      simple: [[{ type: 'simple' }]],
+      'simple-2': [[{ type: 'simple-2' }]],
+      'simple-resolve': [[{ type: 'from-resolve-props' }]],
+      'component-actions-resolve': [[{ type: 'actions>resolveProps' }]],
+      x: [[{ type: 'value-of-x' }]],
+      xx: [[{ type: 'value-of-x' }]]
+    });
+  });
+});