Merge branch 'master' of github.com:formio/core into fix-truncate-multiple-spaces

Author: travist

src/error/DereferenceError.ts

@@ -0,0 +1,10 @@
+import { ProcessorContext } from "types";
+export class ProcessorError extends Error {
+    context: Omit<ProcessorContext<any>, 'scope'>;
+    constructor(message: string, context: ProcessorContext<any>, processor: string = 'unknown') {
+        super(message);
+        this.message = `${message}\nin ${processor} at ${context.path}`;
+        const { component, path, data, row } = context;
+        this.context = {component, path, data, row};
+    }
+};

src/error/ProcessorError.ts

@@ -1,3 +1,2 @@
 export * from './FieldError';
-export * from './ValidatorError';
-export * from './DereferenceError';
+export * from './ProcessorError';

src/error/ValidatorError.ts

@@ -28,9 +28,9 @@ export type EvaluatorContext = {
 export type EvaluatorFn = (context: EvaluatorContext) => any;
 
 export function evaluate(
-    context: EvaluatorContext, 
-    evaluation: string, 
-    ret: string = 'result', 
+    context: EvaluatorContext,
+    evaluation: string,
+    ret: string = 'result',
     evalContextFn?: EvaluatorFn,
     fnName?: string,
     options: any = {}
@@ -49,8 +49,8 @@ export function evaluate(
 }
 
 export function interpolate(
-    context: EvaluatorContext, 
-    evaluation: string, 
+    context: EvaluatorContext,
+    evaluation: string,
     evalContextFn?: EvaluatorFn
 ) : string {
     return evaluate(context, evaluation, undefined, evalContextFn, 'interpolate', {

src/error/index.ts

@@ -1,4 +1,4 @@
-import { DereferenceError } from "error";
+import { ProcessorError } from "error";
 import {
     ProcessorFn,
     ProcessorScope,
@@ -37,7 +37,7 @@ export const dereferenceProcess: ProcessorFn<DereferenceScope> = async (context)
         return;
     }
     if (!config?.database) {
-        throw new DereferenceError('Cannot dereference resource value without a database config object');
+        throw new ProcessorError('Cannot dereference resource value without a database config object', context, 'dereference');
     }
 
     try {
@@ -49,7 +49,7 @@ export const dereferenceProcess: ProcessorFn<DereferenceScope> = async (context)
         component.components = vmCompatibleComponents;
     }
     catch (err: any) {
-        throw new DereferenceError(err.message || err);
+        throw new ProcessorError(err.message || err, context, 'dereference');
     }
 }
 

src/modules/jsonlogic/index.ts

@@ -2,7 +2,8 @@ import { expect } from 'chai';
 
 import { FieldError } from 'error';
 import { validateRequired } from '../validateRequired';
-import { conditionallyHiddenRequiredHiddenField, hiddenRequiredField, requiredNonInputField, simpleTextField } from './fixtures/components';
+
+import { conditionallyHiddenRequiredHiddenField, hiddenRequiredField, requiredNonInputField, simpleTextField, simpleSelectBoxes, simpleRadioField } from './fixtures/components';
 import { processOne } from 'processes/processOne';
 import { generateProcessorContext } from './fixtures/util';
 import { ProcessorsContext, ValidationScope } from 'types';
@@ -25,6 +26,56 @@ it('Validating a simple component that is required and present in the data will
     expect(result).to.equal(null);
 });
 
+
+it('Validating a simple radio component that is required and present in the data with value set to false will return null', async () => {
+    const component = { ...simpleRadioField, validate: { required: true }, values: [
+        {
+            label: 'Yes',
+            value: 'true',
+        },
+        {
+            label: 'No',
+            value: 'false',
+        }] };
+    const data = { component: false };
+    const context = generateProcessorContext(component, data);
+    const result = await validateRequired(context);
+    expect(result).to.equal(null);
+});
+
+
+it('Validating a simple selectbox that is required and present in the data with value set to zero will return null', async () => {
+    const component = { ...simpleSelectBoxes, validate: { required: true }, values: [
+        {
+            label: 'true',
+            value: 'true',
+        },
+        {
+            label: 'Null',
+            value: '0',
+        }] };
+    const data = { component: 0 };
+    const context = generateProcessorContext(component, data);
+    const result = await validateRequired(context);
+    expect(result).to.equal(null);
+});
+
+it('Validating a simple selectbox that is required and present in the data with value set to false will return null', async () => {
+    const component = { ...simpleSelectBoxes, validate: { required: true }, values: [
+        {
+            label: 'true',
+            value: 'true',
+        },
+        {
+            label: 'false',
+            value: 'false',
+        }] };
+    const data = { component: false };
+    const context = generateProcessorContext(component, data);
+    const result = await validateRequired(context);
+    expect(result).to.equal(null);
+});
+
 it('Validating a simple component that is not required and present in the data will return null', async () => {
     const component = simpleTextField;
     const data = { component: 'a simple value' };