@abgov/jsonforms-components 0.0.1 → 1.2.0

package/src/lib/ErrorHandling/GoAErrorControl.tsx

@@ -1,53 +0,0 @@
-/**
- * The error control is invoked whenever no other control can be found.  It is used to display
- * an error to the developers indicating that they have misconfigured one or more of their schemas and
- * that they need to take a close look.  It will attempt to provide information to guide the developer
- * toward fixing the error.
- */
-
-import React from 'react';
-import { ControlProps, JsonSchema, RankedTester, rankWith } from '@jsonforms/core';
-import { withJsonFormsControlProps } from '@jsonforms/react';
-import { isNullSchema, isValidJsonObject } from './errorCheck';
-import { getUISchemaErrors } from './schemaValidation';
-import { MessageControl } from './MessageControl';
-
-const isValidJsonSchema = (schema: JsonSchema): string | null => {
-  if (isNullSchema(schema)) {
-    return '';
-  }
-  if (!isValidJsonObject(schema)) {
-    return 'Unable to render: json schema is not valid.';
-  }
-  return null;
-};
-
-// Some 'errors' need not be reported, but we want to handle them
-// here.  e.g.  A layout with empty elements should be quietly ignored.
-// this is handled by the errors !== '' check.
-const ErrorControl = (props: ControlProps): JSX.Element => {
-  const { schema, uischema } = props;
-  // Report data schema errors over ui schema ones, as errors in the former
-  // can cause cascading errors in the latter.
-  const dataSchemaErrors = isValidJsonSchema(schema);
-  if (dataSchemaErrors && dataSchemaErrors !== '') {
-    return <p>{dataSchemaErrors}</p>;
-  }
-  const uiSchemaErrors = getUISchemaErrors(uischema, schema);
-  if (uiSchemaErrors && uiSchemaErrors !== '') {
-    return MessageControl(uiSchemaErrors);
-  }
-  return <span />;
-};
-
-/**
- * Note: by returning a rank of 1000, we are saying that this renderer is very important,
- * one that must get used if there are any errors whatsoever.
- */
-export const GoAErrorControlTester: RankedTester = rankWith(1000, (uischema, schema, context) => {
-  const validJsonSchema = isValidJsonSchema(schema);
-  const validUiSchema = getUISchemaErrors(uischema, schema);
-  return validUiSchema != null || validJsonSchema != null;
-});
-
-export default withJsonFormsControlProps(ErrorControl);

package/src/lib/ErrorHandling/categorizationValidation.spec.ts

@@ -1,98 +0,0 @@
-import {
-  errCategorizationHasNoElements,
-  errCategorizationHasNoVariant,
-  errCategorizationHasNonCategories,
-  errNoElements,
-  getUISchemaErrors,
-} from './schemaValidation';
-
-const dataSchema = {
-  type: 'object',
-  properties: {
-    firstName: {
-      type: 'string',
-    },
-    birthDate: {
-      type: 'string',
-      format: 'date',
-    },
-  },
-};
-
-const validCategorization = {
-  type: 'Categorization',
-  elements: [
-    {
-      type: 'Category',
-      elements: [
-        {
-          type: 'Category',
-          elements: [
-            {
-              type: 'Control',
-              scope: '#/properties/firstName',
-            },
-          ],
-        },
-      ],
-    },
-  ],
-  options: { variant: 'stepper' },
-};
-const categorizationWithNoCategories = {
-  type: 'Categorization',
-  elements: [
-    {
-      type: 'Category',
-      elements: [{ type: 'Control', scope: '#/properties/firstName' }],
-    },
-    {
-      type: 'VerticalLayout',
-      elements: [{ type: 'Control', scope: '#/properties/birthDate' }],
-    },
-  ],
-  options: { variant: 'stepper' },
-};
-const categorizationWithNoElements = {
-  type: 'Categorization',
-  options: { variant: 'stepper' },
-};
-const categoryHasNoElements = {
-  type: 'Categorization',
-  elements: [{ type: 'Category' }],
-  options: { variant: 'stepper' },
-};
-const categorizationWithNoVariant = {
-  type: 'Categorization',
-  elements: [{ type: 'Category', elements: [] }],
-};
-
-describe('check error processing', () => {
-  describe('categorization validation', () => {
-    it('ignores valid categorizations', () => {
-      const err = getUISchemaErrors(validCategorization, dataSchema);
-      expect(err).toBe(null);
-    });
-
-    it('can detect non-category element', () => {
-      const err = getUISchemaErrors(categorizationWithNoCategories, dataSchema);
-      console.log(err);
-      expect(err).toMatch(errCategorizationHasNonCategories);
-    });
-
-    it('can detect categorization without elements', () => {
-      const err = getUISchemaErrors(categorizationWithNoElements, dataSchema);
-      expect(err).toMatch(errCategorizationHasNoElements);
-    });
-
-    it('can detect a Category with no elements', () => {
-      const err = getUISchemaErrors(categoryHasNoElements, dataSchema);
-      expect(err).toMatch(errNoElements('Category'));
-    });
-
-    it('can detect Categorization with no variant', () => {
-      const err = getUISchemaErrors(categorizationWithNoVariant, dataSchema);
-      expect(err).toMatch(errCategorizationHasNoVariant);
-    });
-  });
-});

package/src/lib/ErrorHandling/controlValildation.spec.ts

@@ -1,57 +0,0 @@
-import { errMalformedScope, errMissingScope, errUnknownScope, getUISchemaErrors } from './schemaValidation';
-
-const dataSchema = {
-  type: 'object',
-  properties: {
-    firstName: {
-      type: 'string',
-    },
-    birthDate: {
-      type: 'string',
-      format: 'date',
-    },
-  },
-};
-
-const validControl = {
-  type: 'Control',
-  scope: '#/properties/firstName',
-};
-
-const malformedScope = {
-  type: 'Control',
-  scope: '#properties/firstName',
-};
-
-const unknownScope = {
-  type: 'Control',
-  scope: '#/properties/ouch/unknown/scope',
-};
-
-const missingScope = {
-  type: 'Control',
-};
-
-describe('check error processing', () => {
-  describe('control validation', () => {
-    it('ignores valid control schema', () => {
-      const err = getUISchemaErrors(validControl, dataSchema);
-      expect(err).toBe(null);
-    });
-
-    it('has malformed scope', () => {
-      const err = getUISchemaErrors(malformedScope, dataSchema);
-      expect(err).toBe(errMalformedScope(malformedScope.scope));
-    });
-
-    it('has unknown scope', () => {
-      const err = getUISchemaErrors(unknownScope, dataSchema);
-      expect(err).toBe(errUnknownScope(unknownScope.scope));
-    });
-
-    it('has missing scope', () => {
-      const err = getUISchemaErrors(missingScope, dataSchema);
-      expect(err).toBe(errMissingScope);
-    });
-  });
-});

package/src/lib/ErrorHandling/errorCheck.spec.ts

@@ -1,185 +0,0 @@
-import {
-  hasElements,
-  hasVariant,
-  isCategorization,
-  isControlWithNoScope,
-  isEmptyElements,
-  isKnownType,
-  isLayoutType,
-  isScopedPrefixed,
-  isValidScope,
-} from './errorCheck';
-
-const dataSchema = {
-  type: 'object',
-  properties: {
-    firstName: {
-      type: 'string',
-    },
-    birthDate: {
-      type: 'string',
-      format: 'date',
-    },
-  },
-};
-
-// Note: The number in the description is the element index, and it
-// is used to refer to the element in the unit tests.  Please keep them
-// up to date.
-const uiSchema = {
-  type: 'VerticalLayout',
-  elements: [
-    {
-      type: 'Control',
-      scope: '#/properties/firstName',
-      description: 'valid scope test (0)',
-    },
-    {
-      type: 'Control',
-      scope: '#/properties/lastName',
-      description: 'missing property test (1)',
-    },
-    {
-      type: 'Control',
-      scope: '#/properties/birthDate',
-      description: 'Date test (2)',
-      options: {
-        componentProps: {
-          name: 'Calendar name',
-          min: '2023-02-01',
-          max: '2025-02-01',
-        },
-      },
-    },
-    {
-      type: 'Bob',
-      scope: 'properties/bob',
-      description: 'malformed scope test (3)',
-    },
-    {
-      type: 'Control',
-      description: 'missing scope test (4)',
-    },
-    {
-      type: 'HorizontalLayout',
-      description: 'Layout with no elements (5)',
-    },
-    {
-      type: 'VerticalLayout',
-      elements: [],
-      description: 'Layout with empty elements (6)',
-    },
-    {
-      type: 'Categorization',
-      description: 'Valid Categorization (7)',
-      elements: [
-        {
-          type: 'Category',
-          elements: [
-            {
-              type: 'Category',
-              elements: [
-                {
-                  type: 'Control',
-                  scope: '#/properties/firstName',
-                },
-              ],
-            },
-          ],
-        },
-      ],
-      options: {
-        variant: 'stepper',
-      },
-    },
-  ],
-};
-
-describe('check error processing', () => {
-  describe('data schema', () => {
-    it('parses correctly', () => {
-      expect(dataSchema).toEqual(
-        expect.objectContaining({
-          type: 'object',
-          properties: expect.objectContaining({
-            firstName: expect.objectContaining({ type: 'string' }),
-          }),
-        })
-      );
-    });
-  });
-
-  describe('ui schema', () => {
-    it('parses correctly', () => {
-      expect(uiSchema).toEqual(
-        expect.objectContaining({
-          type: 'VerticalLayout',
-          elements: expect.arrayContaining([
-            expect.objectContaining({ scope: expect.stringContaining('#/properties/firstName') }),
-            expect.objectContaining({ scope: expect.stringContaining('#/properties/birthDate') }),
-          ]),
-        })
-      );
-    });
-  });
-
-  describe('testing scope', () => {
-    it('can verify valid scope', () => {
-      const isValid = isValidScope(uiSchema.elements[0], dataSchema);
-      expect(isValid).toBe(true);
-    });
-
-    it('can detect missing property', () => {
-      const isValid = isValidScope(uiSchema.elements[1], dataSchema);
-      expect(isValid).toBe(false);
-    });
-
-    it('can detect malformed scope', () => {
-      const isValid = isScopedPrefixed(uiSchema.elements[3].scope as string);
-      expect(isValid).toBe(false);
-    });
-
-    it('can detect missing scope', () => {
-      const isValid = isControlWithNoScope(uiSchema.elements[4]);
-      expect(isValid).toBe(true);
-    });
-  });
-
-  describe('testing layout', () => {
-    it('can verify a valid layout', () => {
-      const isValid = isLayoutType(uiSchema);
-      expect(isValid).toBe(true);
-    });
-
-    it('can verify layout has elements', () => {
-      const isValid = hasElements(uiSchema);
-      expect(isValid).toBe(true);
-    });
-
-    it('can detect layout without elements', () => {
-      const subSchema = uiSchema.elements[5];
-      const isValid = isKnownType(subSchema) && hasElements(subSchema);
-      expect(isValid).toBe(false);
-    });
-
-    it('can detect layout with an empty set of elements', () => {
-      const subSchema = uiSchema.elements[6];
-      const isValid = isKnownType(subSchema) && isEmptyElements(subSchema);
-      expect(isValid).toBe(true);
-    });
-  });
-
-  describe('testing categorization', () => {
-    it('can verify categorization', () => {
-      const subSchema = uiSchema.elements[7];
-      const isValid = isCategorization(subSchema);
-      expect(isValid).toBe(true);
-    });
-
-    it('can detect categorization variant', () => {
-      const subSchema = uiSchema.elements[7];
-      const isValid = hasVariant(subSchema);
-      expect(isValid).toBe(true);
-    });
-  });
-});

package/src/lib/ErrorHandling/errorCheck.tsx

@@ -1,86 +0,0 @@
-import { JsonSchema, UISchemaElement, hasType, isControl } from '@jsonforms/core';
-
-export const isNullSchema = (schema: unknown): boolean => {
-  return schema === undefined || schema === null;
-};
-
-export const isValidScope = (uiSchema: UISchemaElement, schema: JsonSchema): boolean => {
-  if (!('scope' in uiSchema)) {
-    return false;
-  }
-  const scopeComponents = (uiSchema.scope as string).split('/');
-  // get rid of the '#' at the beginning of scope
-  scopeComponents.shift();
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let obj = schema as any;
-  // iterate through the schema to ensure each property exists
-  for (const key of scopeComponents) {
-    if (obj && typeof obj === 'object' && key in obj) {
-      obj = obj[key];
-    } else {
-      return false;
-    }
-  }
-  return true;
-};
-
-export const isLayoutType = (schema: UISchemaElement): boolean => {
-  return (
-    hasType(schema, 'VerticalLayout') ||
-    hasType(schema, 'HorizontalLayout') ||
-    hasType(schema, 'Categorization') ||
-    hasType(schema, 'Group')
-  );
-};
-
-export const isKnownType = (schema: UISchemaElement): boolean => {
-  return (
-    hasType(schema, 'Control') || isLayoutType(schema) || hasType(schema, 'HelpContent') || isListWithDetail(schema)
-  );
-};
-
-export const isListWithDetail = (schema: UISchemaElement): boolean => {
-  return hasType(schema, 'ListWithDetail');
-};
-
-export const isScopedPrefixed = (scope: string): boolean => {
-  const scopeComponents = scope.split('/');
-  return scopeComponents.length > 1 && scopeComponents[0] === '#';
-};
-
-export const isEmptyObject = (schema: object): boolean => {
-  return Object.keys(schema).length === 0;
-};
-
-export const isControlWithNoScope = (uiSchema: UISchemaElement): boolean => {
-  return 'type' in uiSchema && uiSchema.type === 'Control' && !('scope' in uiSchema);
-};
-
-export const isCategorization = (uiSchema: UISchemaElement): boolean => {
-  return uiSchema.type === 'Categorization';
-};
-
-export const hasElements = (schema: object): boolean => {
-  return 'elements' in schema && Array.isArray(schema.elements);
-};
-
-export const isEmptyElements = (schema: object): boolean => {
-  return (
-    'elements' in schema &&
-    schema.elements !== undefined &&
-    schema.elements !== null &&
-    Object.keys(schema.elements).length === 0
-  );
-};
-
-export const hasVariant = (schema: UISchemaElement): boolean => {
-  return 'options' in schema && schema.options !== undefined && schema.options !== null && 'variant' in schema.options;
-};
-
-export const isValidJsonObject = (schema: JsonSchema): boolean => {
-  return (
-    (typeof schema === 'object' && Object.keys(schema).length === 0) ||
-    ('properties' in schema && (('type' in schema && schema.type === 'object') || !('type' in schema)))
-  );
-};

package/src/lib/ErrorHandling/layoutValildation.spec.ts

@@ -1,47 +0,0 @@
-import { errNoElements, getUISchemaErrors } from './schemaValidation';
-
-const dataSchema = {
-  type: 'object',
-  properties: {
-    firstName: {
-      type: 'string',
-    },
-    birthDate: {
-      type: 'string',
-      format: 'date',
-    },
-  },
-};
-
-const validLayout = {
-  type: 'VerticalLayout',
-  elements: [{ type: 'Control', scope: '#/properties/firstName' }],
-};
-
-const hasNoElements = {
-  type: 'HorizontalLayout',
-};
-
-const hasEmptyElement = {
-  type: 'HorizontalLayout',
-  elements: [],
-};
-
-describe('check error processing', () => {
-  describe('layout validation', () => {
-    it('ignores valid layout schema', () => {
-      const err = getUISchemaErrors(validLayout, dataSchema);
-      expect(err).toBe(null);
-    });
-
-    it('has no elements', () => {
-      const err = getUISchemaErrors(hasNoElements, dataSchema);
-      expect(err).toBe(errNoElements(hasNoElements.type));
-    });
-
-    it('has empty elements', () => {
-      const err = getUISchemaErrors(hasEmptyElement, dataSchema);
-      expect(err).toBe(errNoElements(hasEmptyElement.type));
-    });
-  });
-});

package/src/lib/ErrorHandling/otherValildation.spec.ts

@@ -1,74 +0,0 @@
-import { UISchemaElement } from '@jsonforms/core';
-import {
-  errMissingScope,
-  errMissingType,
-  errUnknownScope,
-  errUnknownType,
-  getUISchemaErrors,
-} from './schemaValidation';
-
-const dataSchema = {
-  type: 'object',
-  properties: {
-    firstName: {
-      type: 'string',
-    },
-    birthDate: {
-      type: 'string',
-      format: 'date',
-    },
-  },
-};
-
-const missingType = {
-  elements: [{ type: 'Control', scope: '#/properties/firstName' }],
-};
-
-const unknownType = {
-  type: 'BobsYerUncle',
-  elements: [{ type: 'Control', scope: '#/properties/firstName' }],
-};
-
-const validListWithDetails = {
-  type: 'ListWithDetail',
-  scope: '#/properties/firstName',
-};
-const listWithDetailsNoScope = {
-  type: 'ListWithDetail',
-};
-
-const listWithDetailsInvalidScope = {
-  type: 'ListWithDetail',
-  scope: '#/properties/Yabadabadooo',
-};
-
-describe('check error processing', () => {
-  describe('type validation', () => {
-    it('detects missing type', () => {
-      const err = getUISchemaErrors(missingType as unknown as UISchemaElement, dataSchema);
-      expect(err).toBe(errMissingType);
-    });
-
-    it('detects unknown type', () => {
-      const err = getUISchemaErrors(unknownType, dataSchema);
-      expect(err).toBe(errUnknownType(unknownType.type));
-    });
-  });
-
-  describe('List with Detail validation', () => {
-    it('likes valid ListWithDetails', () => {
-      const err = getUISchemaErrors(validListWithDetails, dataSchema);
-      expect(err).toBe(null);
-    });
-
-    it('detects no scope', () => {
-      const err = getUISchemaErrors(listWithDetailsNoScope, dataSchema);
-      expect(err).toBe(errMissingScope);
-    });
-
-    it('detects unknown scope', () => {
-      const err = getUISchemaErrors(listWithDetailsInvalidScope, dataSchema);
-      expect(err).toBe(errUnknownScope(listWithDetailsInvalidScope.scope));
-    });
-  });
-});