@ng-formworks/core 17.2.7 → 17.3.0

package/src/lib/shared/convert-schema-to-draft6.function.ts

@@ -1,321 +0,0 @@
-import cloneDeep from 'lodash/cloneDeep';
-
-/**
- * 'convertSchemaToDraft6' function
- *
- * Converts a JSON Schema from draft 1 through 4 format to draft 6 format
- *
- * Inspired by on geraintluff's JSON Schema 3 to 4 compatibility function:
- *   https://github.com/geraintluff/json-schema-compatibility
- * Also uses suggestions from AJV's JSON Schema 4 to 6 migration guide:
- *   https://github.com/epoberezkin/ajv/releases/tag/5.0.0
- * And additional details from the official JSON Schema documentation:
- *   http://json-schema.org
- *
- * //  { object } originalSchema - JSON schema (draft 1, 2, 3, 4, or 6)
- * //  { OptionObject = {} } options - options: parent schema changed?, schema draft number?
- * // { object } - JSON schema (draft 6)
- */
-export interface OptionObject { changed?: boolean; draft?: number; }
-export function convertSchemaToDraft6(schema, options: OptionObject = {}) {
-  let draft: number = options.draft || null;
-  let changed: boolean = options.changed || false;
-
-  if (typeof schema !== 'object') { return schema; }
-  if (typeof schema.map === 'function') {
-    return [...schema.map(subSchema => convertSchemaToDraft6(subSchema, { changed, draft }))];
-  }
-  let newSchema = { ...schema };
-  const simpleTypes = ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string'];
-
-  if (typeof newSchema.$schema === 'string' &&
-    /http\:\/\/json\-schema\.org\/draft\-0\d\/schema\#/.test(newSchema.$schema)
-  ) {
-    draft = newSchema.$schema[30];
-  }
-
-  // Convert v1-v2 'contentEncoding' to 'media.binaryEncoding'
-  // Note: This is only used in JSON hyper-schema (not regular JSON schema)
-  if (newSchema.contentEncoding) {
-    newSchema.media = { binaryEncoding: newSchema.contentEncoding };
-    delete newSchema.contentEncoding;
-    changed = true;
-  }
-
-  // Convert v1-v3 'extends' to 'allOf'
-  if (typeof newSchema.extends === 'object') {
-    newSchema.allOf = typeof newSchema.extends.map === 'function' ?
-      newSchema.extends.map(subSchema => convertSchemaToDraft6(subSchema, { changed, draft })) :
-      [convertSchemaToDraft6(newSchema.extends, { changed, draft })];
-    delete newSchema.extends;
-    changed = true;
-  }
-
-  // Convert v1-v3 'disallow' to 'not'
-  if (newSchema.disallow) {
-    if (typeof newSchema.disallow === 'string') {
-      newSchema.not = { type: newSchema.disallow };
-    } else if (typeof newSchema.disallow.map === 'function') {
-      newSchema.not = {
-        anyOf: newSchema.disallow
-          .map(type => typeof type === 'object' ? type : { type })
-      };
-    }
-    delete newSchema.disallow;
-    changed = true;
-  }
-
-  // Convert v3 string 'dependencies' properties to arrays
-  if (typeof newSchema.dependencies === 'object' &&
-    Object.keys(newSchema.dependencies)
-      .some(key => typeof newSchema.dependencies[key] === 'string')
-  ) {
-    newSchema.dependencies = { ...newSchema.dependencies };
-    Object.keys(newSchema.dependencies)
-      .filter(key => typeof newSchema.dependencies[key] === 'string')
-      .forEach(key => newSchema.dependencies[key] = [newSchema.dependencies[key]]);
-    changed = true;
-  }
-
-  // Convert v1 'maxDecimal' to 'multipleOf'
-  if (typeof newSchema.maxDecimal === 'number') {
-    newSchema.multipleOf = 1 / Math.pow(10, newSchema.maxDecimal);
-    delete newSchema.divisibleBy;
-    changed = true;
-    if (!draft || draft === 2) { draft = 1; }
-  }
-
-  // Convert v2-v3 'divisibleBy' to 'multipleOf'
-  if (typeof newSchema.divisibleBy === 'number') {
-    newSchema.multipleOf = newSchema.divisibleBy;
-    delete newSchema.divisibleBy;
-    changed = true;
-  }
-
-  // Convert v1-v2 boolean 'minimumCanEqual' to 'exclusiveMinimum'
-  if (typeof newSchema.minimum === 'number' && newSchema.minimumCanEqual === false) {
-    newSchema.exclusiveMinimum = newSchema.minimum;
-    delete newSchema.minimum;
-    changed = true;
-    if (!draft) { draft = 2; }
-  } else if (typeof newSchema.minimumCanEqual === 'boolean') {
-    delete newSchema.minimumCanEqual;
-    changed = true;
-    if (!draft) { draft = 2; }
-  }
-
-  // Convert v3-v4 boolean 'exclusiveMinimum' to numeric
-  if (typeof newSchema.minimum === 'number' && newSchema.exclusiveMinimum === true) {
-    newSchema.exclusiveMinimum = newSchema.minimum;
-    delete newSchema.minimum;
-    changed = true;
-  } else if (typeof newSchema.exclusiveMinimum === 'boolean') {
-    delete newSchema.exclusiveMinimum;
-    changed = true;
-  }
-
-  // Convert v1-v2 boolean 'maximumCanEqual' to 'exclusiveMaximum'
-  if (typeof newSchema.maximum === 'number' && newSchema.maximumCanEqual === false) {
-    newSchema.exclusiveMaximum = newSchema.maximum;
-    delete newSchema.maximum;
-    changed = true;
-    if (!draft) { draft = 2; }
-  } else if (typeof newSchema.maximumCanEqual === 'boolean') {
-    delete newSchema.maximumCanEqual;
-    changed = true;
-    if (!draft) { draft = 2; }
-  }
-
-  // Convert v3-v4 boolean 'exclusiveMaximum' to numeric
-  if (typeof newSchema.maximum === 'number' && newSchema.exclusiveMaximum === true) {
-    newSchema.exclusiveMaximum = newSchema.maximum;
-    delete newSchema.maximum;
-    changed = true;
-  } else if (typeof newSchema.exclusiveMaximum === 'boolean') {
-    delete newSchema.exclusiveMaximum;
-    changed = true;
-  }
-
-  // Search object 'properties' for 'optional', 'required', and 'requires' items,
-  // and convert them into object 'required' arrays and 'dependencies' objects
-  if (typeof newSchema.properties === 'object') {
-    const properties = { ...newSchema.properties };
-    const requiredKeys = Array.isArray(newSchema.required) ?
-      new Set(newSchema.required) : new Set();
-
-    // Convert v1-v2 boolean 'optional' properties to 'required' array
-    if (draft === 1 || draft === 2 ||
-      Object.keys(properties).some(key => properties[key].optional === true)
-    ) {
-      Object.keys(properties)
-        .filter(key => properties[key].optional !== true)
-        .forEach(key => requiredKeys.add(key));
-      changed = true;
-      if (!draft) { draft = 2; }
-    }
-
-    // Convert v3 boolean 'required' properties to 'required' array
-    if (Object.keys(properties).some(key => properties[key].required === true)) {
-      Object.keys(properties)
-        .filter(key => properties[key].required === true)
-        .forEach(key => requiredKeys.add(key));
-      changed = true;
-    }
-
-    if (requiredKeys.size) { newSchema.required = Array.from(requiredKeys); }
-
-    // Convert v1-v2 array or string 'requires' properties to 'dependencies' object
-    if (Object.keys(properties).some(key => properties[key].requires)) {
-      const dependencies = typeof newSchema.dependencies === 'object' ?
-        { ...newSchema.dependencies } : {};
-      Object.keys(properties)
-        .filter(key => properties[key].requires)
-        .forEach(key => dependencies[key] =
-          typeof properties[key].requires === 'string' ?
-            [properties[key].requires] : properties[key].requires
-        );
-      newSchema.dependencies = dependencies;
-      changed = true;
-      if (!draft) { draft = 2; }
-    }
-
-    newSchema.properties = properties;
-  }
-
-  // Revove v1-v2 boolean 'optional' key
-  if (typeof newSchema.optional === 'boolean') {
-    delete newSchema.optional;
-    changed = true;
-    if (!draft) { draft = 2; }
-  }
-
-  // Revove v1-v2 'requires' key
-  if (newSchema.requires) {
-    delete newSchema.requires;
-  }
-
-  // Revove v3 boolean 'required' key
-  if (typeof newSchema.required === 'boolean') {
-    delete newSchema.required;
-  }
-
-  // Convert id to $id
-  if (typeof newSchema.id === 'string' && !newSchema.$id) {
-    if (newSchema.id.slice(-1) === '#') {
-      newSchema.id = newSchema.id.slice(0, -1);
-    }
-    newSchema.$id = newSchema.id + '-CONVERTED-TO-DRAFT-06#';
-    delete newSchema.id;
-    changed = true;
-  }
-
-  // Check if v1-v3 'any' or object types will be converted
-  if (newSchema.type && (typeof newSchema.type.every === 'function' ?
-    !newSchema.type.every(type => simpleTypes.includes(type)) :
-    !simpleTypes.includes(newSchema.type)
-  )) {
-    changed = true;
-  }
-
-  // If schema changed, update or remove $schema identifier
-  if (typeof newSchema.$schema === 'string' &&
-    /http\:\/\/json\-schema\.org\/draft\-0[1-4]\/schema\#/.test(newSchema.$schema)
-  ) {
-    newSchema.$schema = 'http://json-schema.org/draft-06/schema#';
-    changed = true;
-  } else if (changed && typeof newSchema.$schema === 'string') {
-    const addToDescription = 'Converted to draft 6 from ' + newSchema.$schema;
-    if (typeof newSchema.description === 'string' && newSchema.description.length) {
-      newSchema.description += '\n' + addToDescription;
-    } else {
-      newSchema.description = addToDescription;
-    }
-    delete newSchema.$schema;
-  }
-
-  // Convert v1-v3 'any' and object types
-  if (newSchema.type && (typeof newSchema.type.every === 'function' ?
-    !newSchema.type.every(type => simpleTypes.includes(type)) :
-    !simpleTypes.includes(newSchema.type)
-  )) {
-    if (newSchema.type.length === 1) { newSchema.type = newSchema.type[0]; }
-    if (typeof newSchema.type === 'string') {
-      // Convert string 'any' type to array of all standard types
-      if (newSchema.type === 'any') {
-        newSchema.type = simpleTypes;
-        // Delete non-standard string type
-      } else {
-        delete newSchema.type;
-      }
-    } else if (typeof newSchema.type === 'object') {
-      if (typeof newSchema.type.every === 'function') {
-        // If array of strings, only allow standard types
-        if (newSchema.type.every(type => typeof type === 'string')) {
-          newSchema.type = newSchema.type.some(type => type === 'any') ?
-            newSchema.type = simpleTypes :
-            newSchema.type.filter(type => simpleTypes.includes(type));
-          // If type is an array with objects, convert the current schema to an 'anyOf' array
-        } else if (newSchema.type.length > 1) {
-          const arrayKeys = ['additionalItems', 'items', 'maxItems', 'minItems', 'uniqueItems', 'contains'];
-          const numberKeys = ['multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum'];
-          const objectKeys = ['maxProperties', 'minProperties', 'required', 'additionalProperties',
-            'properties', 'patternProperties', 'dependencies', 'propertyNames'];
-          const stringKeys = ['maxLength', 'minLength', 'pattern', 'format'];
-          const filterKeys = {
-            'array': [...numberKeys, ...objectKeys, ...stringKeys],
-            'integer': [...arrayKeys, ...objectKeys, ...stringKeys],
-            'number': [...arrayKeys, ...objectKeys, ...stringKeys],
-            'object': [...arrayKeys, ...numberKeys, ...stringKeys],
-            'string': [...arrayKeys, ...numberKeys, ...objectKeys],
-            'all': [...arrayKeys, ...numberKeys, ...objectKeys, ...stringKeys],
-          };
-          const anyOf = [];
-          for (const type of newSchema.type) {
-            const newType = typeof type === 'string' ? { type } : { ...type };
-            Object.keys(newSchema)
-              .filter(key => !newType.hasOwnProperty(key) &&
-                ![...(filterKeys[newType.type] || filterKeys.all), 'type', 'default']
-                  .includes(key)
-              )
-              .forEach(key => newType[key] = newSchema[key]);
-            anyOf.push(newType);
-          }
-          newSchema = newSchema.hasOwnProperty('default') ?
-            { anyOf, default: newSchema.default } : { anyOf };
-          // If type is an object, merge it with the current schema
-        } else {
-          const typeSchema = newSchema.type;
-          delete newSchema.type;
-          Object.assign(newSchema, typeSchema);
-        }
-      }
-    } else {
-      delete newSchema.type;
-    }
-  }
-
-  // Convert sub schemas
-  Object.keys(newSchema)
-    .filter(key => typeof newSchema[key] === 'object')
-    .forEach(key => {
-      if (
-        ['definitions', 'dependencies', 'properties', 'patternProperties']
-          .includes(key) && typeof newSchema[key].map !== 'function'
-      ) {
-        const newKey = {};
-        Object.keys(newSchema[key]).forEach(subKey => newKey[subKey] =
-          convertSchemaToDraft6(newSchema[key][subKey], { changed, draft })
-        );
-        newSchema[key] = newKey;
-      } else if (
-        ['items', 'additionalItems', 'additionalProperties',
-          'allOf', 'anyOf', 'oneOf', 'not'].includes(key)
-      ) {
-        newSchema[key] = convertSchemaToDraft6(newSchema[key], { changed, draft });
-      } else {
-        newSchema[key] = cloneDeep(newSchema[key]);
-      }
-    });
-
-  return newSchema;
-}