@takeshape/schema 7.194.0

package/es/validate.js

@@ -0,0 +1,764 @@
+import { createAjv } from '@takeshape/json-schema';
+import { SchemaValidationError } from '@takeshape/errors';
+import coerce from 'semver/functions/coerce';
+import eq from 'semver/functions/eq';
+import neq from 'semver/functions/neq';
+import isUndefined from 'lodash/isUndefined';
+import { CURRENT_SCHEMA_VERSION, LEGACY_SCHEMA_VERSION, LEGACY_API_VERSION } from './versions';
+import { defaultWorkflow } from './workflows';
+import projectSchemaV1 from './schemas/project-schema/v1.0.0.json';
+import projectSchemaV3 from './schemas/project-schema/v3.0.0.json';
+import projectSchemaV3_1 from './schemas/project-schema/v3.1.0.json';
+import projectSchemaV3_2 from './schemas/project-schema/v3.2.0.json';
+import projectSchemaV3_3 from './schemas/project-schema/v3.3.0.json';
+import projectSchemaV3_4 from './schemas/project-schema/v3.4.0.json';
+import projectSchemaV3_5 from './schemas/project-schema/v3.5.0.json';
+import projectSchemaV3_5_1 from './schemas/project-schema/v3.5.1.json';
+import projectSchemaV3_6_0 from './schemas/project-schema/v3.6.0.json';
+import metaSchemaV1 from './schemas/project-schema/meta-schema-v1.0.0.json';
+import metaSchemaV3 from './schemas/project-schema/meta-schema-v3.0.0.json';
+import metaSchemaV3_1 from './schemas/project-schema/meta-schema-v3.1.0.json';
+import metaSchemaV3_2 from './schemas/project-schema/meta-schema-v3.2.0.json';
+import metaSchemaV3_3 from './schemas/project-schema/meta-schema-v3.3.0.json';
+import metaSchemaV3_4 from './schemas/project-schema/meta-schema-v3.4.0.json';
+import metaSchemaV3_5 from './schemas/project-schema/meta-schema-v3.5.0.json';
+import metaSchemaV3_5_1 from './schemas/project-schema/meta-schema-v3.5.1.json';
+import metaSchemaV3_6_0 from './schemas/project-schema/meta-schema-v3.6.0.json';
+import authSchemas from './schemas/auth-schemas.json';
+import { modelResolvers, resolverList } from './resolvers';
+import { getAllNamespaceShapes, visitShapeProperties, getAllRefsInShapes } from './schema-util';
+import { builtInShapes } from './builtin-schema';
+import { isValidTemplate, parseReturnShape } from './template-shapes';
+import { isComposeResolver } from './types';
+import { refItemToAtRef, refItemToShapeName } from './refs';
+import { scalars } from './scalars';
+import { enumerateOneOfKeys, isUnionSchema } from './unions';
+import { isEnumSchema } from './enum';
+
+function findDuplicates(items) {
+  const seen = {};
+
+  for (let item of items) {
+    if (seen[item.value]) {
+      seen[item.value].push(item.path);
+    } else {
+      seen[item.value] = [item.path];
+    }
+  }
+
+  return Object.entries(seen).filter(entry => entry[1].length > 1).flatMap(entry => ({
+    value: entry[0],
+    paths: entry[1]
+  }));
+}
+
+function checkContentTypeNames(contentTypes) {
+  const items = Object.entries(contentTypes).map(entry => ({
+    path: ['contentType', entry[0], 'name'],
+    value: entry[1].name.toLowerCase()
+  }));
+  return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+    path,
+    type: 'conflict',
+    message: `Content types must have unique names. "${dupe.value}" is not unique.`
+  })));
+}
+
+function checkShapeIds(shapes) {
+  const items = Object.entries(shapes).map(entry => ({
+    path: ['shapes', entry[0], 'id'],
+    value: entry[1].id
+  }));
+  return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+    path,
+    type: 'conflict',
+    message: `Shapes must have unique ids. "${dupe.value}" is not unique.`
+  })));
+}
+
+function checkShapeNames(shapes) {
+  Object.entries(shapes).map(entry => ({
+    path: ['shapes', entry[0], 'id'],
+    value: entry[1].id
+  }));
+  return Object.entries(shapes).filter(([name, shape]) => name !== shape.name).map(([name, shape]) => ({
+    path: ['shapes', name, 'name'],
+    type: 'conflict',
+    message: `Shape.name "${shape.name}" must match key "${name}".`
+  }));
+}
+
+function checkWorkflowStepNames(workflows) {
+  return Object.entries(workflows).flatMap(([name, workflow]) => {
+    const items = workflow.steps.map((step, i) => ({
+      path: ['workflows', name, 'steps', i, 'name'],
+      value: step.name.toLowerCase()
+    }));
+    return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+      path,
+      type: 'conflict',
+      message: `Workflow steps must have unique names. "${dupe.value}" is not unique in workflow "${workflow.name}."`
+    })));
+  });
+}
+
+function checkWorkflowStepKeys(workflows) {
+  const items = Object.entries(workflows).flatMap(([name, workflow]) => workflow.steps.map((step, i) => ({
+    path: ['workflows', name, 'steps', i, 'key'],
+    value: step.key
+  })));
+  return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+    path,
+    type: 'conflict',
+    message: `Workflow keys must be unique at the schema level. Key "${dupe.value}" is not unique.`
+  })));
+}
+
+function validateWorkflowVersion(projectSchema) {
+  const errors = [];
+
+  if (projectSchema.apiVersion === LEGACY_API_VERSION && Object.keys(projectSchema.workflows).length) {
+    errors.push({
+      path: ['workflows'],
+      type: 'invalidVersion',
+      message: `apiVersion ${projectSchema.apiVersion} does not support workflows`
+    });
+  }
+
+  return errors;
+}
+
+function validateWorkflowsV1(projectSchema) {
+  const errors = validateWorkflowVersion(projectSchema);
+
+  for (const key of Object.keys(projectSchema.contentTypes)) {
+    const contentType = projectSchema.contentTypes[key];
+
+    if (contentType.workflow && contentType.workflow !== defaultWorkflow.name && !projectSchema.workflows[contentType.workflow]) {
+      errors.push({
+        type: 'notFound',
+        path: ['contentTypes', key, 'workflow'],
+        message: `Invalid Workflow "${contentType.workflow}" for content type "${contentType.name}"`
+      });
+    }
+  }
+
+  return errors;
+}
+
+function validateWorkflowsV3(projectSchema) {
+  const errors = validateWorkflowVersion(projectSchema);
+
+  for (const name of Object.keys(projectSchema.shapes)) {
+    const shape = projectSchema.shapes[name];
+
+    if (shape.workflow && shape.workflow !== defaultWorkflow.name && !projectSchema.workflows[shape.workflow]) {
+      errors.push({
+        type: 'notFound',
+        path: ['shapes', name, 'workflow'],
+        message: `Invalid Workflow "${shape.workflow}" for shape "${shape.name}"`
+      });
+    }
+  }
+
+  return errors;
+}
+
+function validateResolver(projectSchema, basePath, resolver) {
+  const errors = [];
+
+  const validateBasicResolver = resolver => {
+    var _projectSchema$servic;
+
+    if (resolver.service !== 'takeshape:local' && !((_projectSchema$servic = projectSchema.services) !== null && _projectSchema$servic !== void 0 && _projectSchema$servic[resolver.service])) {
+      errors.push({
+        type: 'notFound',
+        path: basePath.concat(['service']),
+        message: `Invalid service "${resolver.service}"`
+      });
+    }
+
+    if (!resolverList.includes(resolver.name)) {
+      errors.push({
+        type: 'notFound',
+        path: basePath.concat(['name']),
+        message: `Invalid resolver name "${resolver.name}"`
+      });
+    }
+
+    if (modelResolvers.includes(resolver.name)) {
+      var _resolver$options;
+
+      const modelShape = (_resolver$options = resolver.options) !== null && _resolver$options !== void 0 && _resolver$options.model ? projectSchema.shapes[resolver.options.model] : undefined;
+
+      if (!(modelShape !== null && modelShape !== void 0 && modelShape.model)) {
+        var _resolver$options$mod, _resolver$options2;
+
+        errors.push({
+          type: 'notFound',
+          path: basePath.concat(['options', 'model']),
+          message: `Invalid Model Shape "${(_resolver$options$mod = (_resolver$options2 = resolver.options) === null || _resolver$options2 === void 0 ? void 0 : _resolver$options2.model) !== null && _resolver$options$mod !== void 0 ? _resolver$options$mod : ''}"`
+        });
+      }
+    }
+  };
+
+  if (isComposeResolver(resolver)) {
+    resolver.compose.forEach(validateBasicResolver);
+  } else {
+    validateBasicResolver(resolver);
+  }
+
+  return errors;
+} // eslint-disable-next-line max-params
+
+
+function validateQueryConfig(projectSchema, validReturnShapes, operation, type, name) {
+  const location = type === 'query' ? 'queries' : 'mutations';
+  const errors = validateResolver(projectSchema, [location, name, 'resolver'], operation.resolver);
+  const {
+    template,
+    shapeName
+  } = parseReturnShape(projectSchema, operation.shape);
+
+  if (template && !isValidTemplate(template)) {
+    errors.push({
+      type: 'notFound',
+      path: [location, name, 'shape'],
+      message: `Invalid template "${template}" for ${type} "${name}"`
+    });
+  }
+
+  if (!validReturnShapes.has(shapeName)) {
+    errors.push({
+      type: 'notFound',
+      path: [location, name, 'shape'],
+      message: `Invalid shape "${shapeName}" for ${type} "${name}"`
+    });
+  }
+
+  return errors;
+}
+
+function validateQueryConfigs(projectSchema, additionalShapeNames = builtInShapeNames) {
+  const validReturnShapes = new Set(Object.keys(projectSchema.shapes).concat(additionalShapeNames));
+  let errors = [];
+
+  for (const name of Object.keys(projectSchema.queries)) {
+    errors = errors.concat(validateQueryConfig(projectSchema, validReturnShapes, projectSchema.queries[name], 'query', name));
+  }
+
+  for (const name of Object.keys(projectSchema.mutations)) {
+    errors = errors.concat(validateQueryConfig(projectSchema, validReturnShapes, projectSchema.mutations[name], 'mutation', name));
+  }
+
+  return errors;
+}
+
+const builtInShapeNames = [...Object.keys(builtInShapes), ...scalars];
+
+function getModelShapeIds(shapes) {
+  return Object.values(shapes).filter(shape => shape.model).map(shape => shape.id);
+}
+
+const builtInModelShapeIds = getModelShapeIds(builtInShapes);
+
+function isNumberLike(value) {
+  if (typeof value === 'number') {
+    return true;
+  }
+
+  return /^\d+$/.test(value);
+}
+/**
+ * Verify the path has an allOf schema and not just prop named "allOf"
+ */
+
+
+function isAllOfPath(path) {
+  const index = path.indexOf('allOf');
+  return index !== -1 && isNumberLike(path[index + 1]);
+}
+
+function validateRefs(projectSchema, additionalShapeNames = builtInShapeNames) {
+  const errors = [];
+  const shapeNames = new Set([...additionalShapeNames, ...Object.keys(projectSchema.shapes)]);
+  const refs = getAllRefsInShapes(projectSchema);
+
+  if (refs.length > 0) {
+    refs.forEach(item => {
+      const shapeName = refItemToShapeName(item);
+
+      if (!shapeNames.has(shapeName)) {
+        errors.push({
+          type: 'notFound',
+          path: item.path,
+          message: `Invalid ref "${refItemToAtRef(item)}"`
+        });
+      } // Make sure refs inside allOf don't refer to their own Shape
+
+
+      if (item.path[1] === shapeName && isAllOfPath(item.path)) {
+        errors.push({
+          type: 'conflict',
+          path: item.path,
+          message: `allOf cannot be self-referential`
+        });
+      }
+    });
+  }
+
+  return errors;
+}
+
+function validateDirectives(projectSchema, additionalShapeIds = builtInModelShapeIds) {
+  const errors = [];
+  const projectShapeIds = new Set([...getModelShapeIds(projectSchema.shapes), ...additionalShapeIds]);
+  visitShapeProperties(projectSchema.shapes, (schema, path) => {
+    if (schema['@relationship']) {
+      var _schema$Relationship;
+
+      const shapeIds = (_schema$Relationship = schema['@relationship']) === null || _schema$Relationship === void 0 ? void 0 : _schema$Relationship.shapeIds;
+      shapeIds.forEach(shapeId => {
+        if (!projectShapeIds.has(shapeId)) {
+          const propPath = path.concat('@relationship');
+          errors.push({
+            type: 'notFound',
+            path: propPath,
+            message: `Invalid shapeId relationship "${shapeId}" for property "${propPath[4]}" in shape "${propPath[1]}"`
+          });
+        }
+      });
+    }
+
+    if (schema['@resolver']) {
+      const resolver = schema['@resolver'];
+      const propPath = path.concat('@resolver');
+      const resolverErrors = validateResolver(projectSchema, propPath, resolver);
+
+      if (resolverErrors) {
+        errors.push(...resolverErrors);
+      }
+    }
+  });
+  return errors;
+}
+
+function validateOneOfs(projectSchema) {
+  const errors = [];
+  visitShapeProperties(projectSchema.shapes, (schema, path) => {
+    const oneOfPath = schema.items ? ['items', 'oneOf'] : ['oneOf'];
+    schema = schema.items ? schema.items : schema;
+
+    if (schema.oneOf) {
+      if (isUnionSchema(schema)) {
+        const modelsReferenced = enumerateOneOfKeys(projectSchema, schema.oneOf).map(child => child.shapeName).filter(shapeName => projectSchema.shapes[shapeName].model);
+
+        if (modelsReferenced.length) {
+          const shapeNames = modelsReferenced.join(', ');
+          errors.push({
+            type: 'json',
+            path: path.concat(oneOfPath),
+            message: `Invalid refs to ${shapeNames}. oneOf unions cannot reference model shapes. Use @relationship instead`
+          });
+        }
+      } else if (!isEnumSchema(schema)) {
+        errors.push({
+          type: 'json',
+          path: path.concat(oneOfPath),
+          message: `Invalid oneOf must contain only @ref or title + enum/const schemas`
+        });
+      }
+    }
+  });
+  return errors;
+}
+
+function validateLocales(projectSchema) {
+  const {
+    locales,
+    defaultLocale
+  } = projectSchema;
+  const errors = [];
+
+  if (!locales.includes(defaultLocale)) {
+    errors.push({
+      type: 'notFound',
+      path: ['locales'],
+      message: `Default locale "${defaultLocale}" missing from locales`
+    });
+  }
+
+  return errors;
+}
+
+export function addProjectSchemasToAjv(ajv) {
+  ajv.addSchema(metaSchemaV1);
+  ajv.addSchema(projectSchemaV1);
+  ajv.addSchema(metaSchemaV3);
+  ajv.addSchema(projectSchemaV3);
+  ajv.addSchema(metaSchemaV3_1);
+  ajv.addSchema(projectSchemaV3_1);
+  ajv.addSchema(metaSchemaV3_2);
+  ajv.addSchema(projectSchemaV3_2);
+  ajv.addSchema(metaSchemaV3_3);
+  ajv.addSchema(projectSchemaV3_3);
+  ajv.addSchema(metaSchemaV3_4);
+  ajv.addSchema(projectSchemaV3_4);
+  ajv.addSchema(metaSchemaV3_5);
+  ajv.addSchema(projectSchemaV3_5);
+  ajv.addSchema(metaSchemaV3_5_1);
+  ajv.addSchema(projectSchemaV3_5_1);
+  ajv.addSchema(metaSchemaV3_6_0);
+  ajv.addSchema(projectSchemaV3_6_0);
+  return ajv;
+}
+const bracketRegex = /\['|']\./g;
+export function formatError(error) {
+  var _error$message;
+
+  let pathStr = error.dataPath;
+  let message = (_error$message = error.message) !== null && _error$message !== void 0 ? _error$message : '';
+
+  if ('missingProperty' in error.params) {
+    pathStr = `${pathStr}.${error.params.missingProperty}`;
+  }
+
+  if ('additionalProperty' in error.params) {
+    pathStr = `${pathStr}.${error.params.additionalProperty}`;
+    message = `${message} "${error.params.additionalProperty}"`;
+  }
+
+  const path = pathStr === '' ? [] : pathStr.substr(1).replace(bracketRegex, '.').split('.');
+  return {
+    type: 'json',
+    message,
+    path
+  };
+}
+const ajv = createAjv();
+addProjectSchemasToAjv(ajv);
+
+function validateV3X(schemaId, schema, options) {
+  const valid = ajv.validate(schemaId, schema);
+
+  if (!valid && ajv.errors) {
+    return {
+      valid: false,
+      schema: undefined,
+      errors: ajv.errors.map(formatError)
+    };
+  }
+
+  let errors = [];
+  const namespaceShapes = getAllNamespaceShapes(schema);
+  const additionalShapeNames = (options !== null && options !== void 0 && options.additionalShapeNames ? builtInShapeNames.concat(options.additionalShapeNames) : builtInShapeNames).concat(namespaceShapes);
+  const additionalModelShapeIds = options !== null && options !== void 0 && options.additionalModelShapeIds ? builtInModelShapeIds.concat(options.additionalModelShapeIds) : builtInModelShapeIds;
+  errors = errors.concat(checkShapeNames(schema.shapes)).concat(checkShapeIds(schema.shapes)).concat(validateWorkflowsV3(schema)).concat(validateQueryConfigs(schema, additionalShapeNames)).concat(validateRefs(schema, additionalShapeNames)).concat(validateDirectives(schema, additionalModelShapeIds)).concat(validateLocales(schema)).concat(checkWorkflowStepNames(schema.workflows)).concat(checkWorkflowStepKeys(schema.workflows)).concat(validateOneOfs(schema));
+  return errors.length ? {
+    valid: false,
+    schema: undefined,
+    errors
+  } : {
+    valid: true,
+    schema: schema,
+    errors: undefined
+  };
+}
+
+const validators = [{
+  version: '1',
+  schemaId: projectSchemaV1.$id,
+
+  validate(schema) {
+    const schemaV1 = schema;
+    const valid = ajv.validate(this.schemaId, schemaV1);
+
+    if (!valid && ajv.errors) {
+      return {
+        valid: false,
+        schema: undefined,
+        errors: ajv.errors.map(formatError)
+      };
+    }
+
+    let errors = [];
+    errors = errors.concat(checkContentTypeNames(schemaV1.contentTypes)).concat(validateWorkflowsV1(schemaV1)).concat(checkWorkflowStepNames(schemaV1.workflows)).concat(checkWorkflowStepKeys(schemaV1.workflows));
+    return errors.length ? {
+      valid: false,
+      schema: undefined,
+      errors
+    } : {
+      valid: true,
+      schema: schemaV1,
+      errors: undefined
+    };
+  }
+
+}, {
+  version: '3',
+  schemaId: projectSchemaV3.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.1.0',
+  schemaId: projectSchemaV3_1.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.2.0',
+  schemaId: projectSchemaV3_2.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.3.0',
+  schemaId: projectSchemaV3_3.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.4.0',
+  schemaId: projectSchemaV3_4.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.5.0',
+  schemaId: projectSchemaV3_5.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.5.1',
+  schemaId: projectSchemaV3_5_1.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.6.0',
+  schemaId: projectSchemaV3_6_0.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}];
+
+function findValidator(schemaVersion) {
+  const schemaSemVer = coerce(schemaVersion !== null && schemaVersion !== void 0 ? schemaVersion : '1');
+  return validators.find(v => {
+    const validatorSemVer = coerce(v.version);
+    return validatorSemVer && schemaSemVer && eq(validatorSemVer, schemaSemVer);
+  });
+}
+/**
+ * Validates a schema using a matching validation based on the `schemaVersion` property.
+ */
+
+
+export function validateSchema(obj, options) {
+  if (isUndefined(obj)) {
+    return {
+      valid: false,
+      schema: undefined,
+      errors: [{
+        path: [],
+        type: 'undefined',
+        message: 'Schema is undefined'
+      }]
+    };
+  }
+
+  const schema = obj;
+  const validation = findValidator(schema.schemaVersion);
+
+  if (!validation) {
+    return {
+      valid: false,
+      schema: undefined,
+      errors: [{
+        path: [],
+        type: 'invalidVersion',
+        message: 'Unknown schema version'
+      }]
+    };
+  }
+
+  return validation.validate(schema, options);
+}
+export function ensureValidV3Schema(obj) {
+  var _coerce;
+
+  const {
+    valid,
+    schema,
+    errors
+  } = validateSchema(obj);
+
+  if (!valid && errors) {
+    throw new Error(`Invalid Schema "${errors[0].path.join(',')}": "${errors[0].message}"`);
+  }
+
+  if (isUndefined(schema)) {
+    throw new Error(`Invalid schema: schema is undefined`);
+  }
+
+  if (neq('3.0.0', (_coerce = coerce(schema.schemaVersion)) !== null && _coerce !== void 0 ? _coerce : LEGACY_SCHEMA_VERSION)) {
+    throw new Error(`Expected schemaVersion: "3", got "${schema.schemaVersion}"`);
+  }
+
+  return schema;
+}
+export function ensureValidLatestSchema(obj) {
+  var _coerce2;
+
+  const {
+    valid,
+    schema,
+    errors
+  } = validateSchema(obj);
+
+  if (!valid && errors) {
+    throw new Error(`Invalid Schema "${errors[0].path.join(',')}": "${errors[0].message}"`);
+  }
+
+  if (isUndefined(schema)) {
+    throw new Error(`Invalid schema: schema is undefined`);
+  }
+
+  if (neq(CURRENT_SCHEMA_VERSION, (_coerce2 = coerce(schema.schemaVersion)) !== null && _coerce2 !== void 0 ? _coerce2 : LEGACY_SCHEMA_VERSION)) {
+    throw new Error(`Expected schemaVersion: "${CURRENT_SCHEMA_VERSION}", got "${schema.schemaVersion}"`);
+  }
+
+  return schema;
+}
+/**
+ * The roles import validator ensures required properties, and strips several
+ * which might exist in an export but wouldn't apply to an import operation.
+ */
+
+function createRoleInputValidator() {
+  const validator = createAjv({
+    useDefaults: true
+  });
+  const {
+    RoleInput,
+    ...definitions
+  } = authSchemas.definitions;
+  return validator.compile({
+    $id: 'RoleInput',
+    definitions,
+    ...RoleInput
+  });
+}
+/**
+ * Validates and returns a `RoleInput`, which is a subset of the `Role`
+ * type's properties suitable for importing.
+ */
+
+
+export function validateRoleInput(maybeRoleInput) {
+  var _validate$errors;
+
+  const validate = createRoleInputValidator();
+
+  if (validate(maybeRoleInput)) {
+    return maybeRoleInput;
+  }
+
+  throw new SchemaValidationError('RoleInput was invalid', (_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(formatError));
+}
+/**
+ * The roles import validator ensures required properties, and strips several
+ * which might exist in an export but wouldn't apply to an import operation.
+ */
+
+function createRoleImportValidator() {
+  const validator = createAjv({
+    useDefaults: true
+  });
+  const {
+    RoleImport,
+    ...definitions
+  } = authSchemas.definitions;
+  return validator.compile({
+    $id: 'RoleImport',
+    definitions,
+    ...RoleImport
+  });
+}
+/**
+ * Validates and returns a `RoleImport` array, which is a collection of `RoleInput`s.
+ */
+
+
+export function validateRoleImport(maybeRoles) {
+  var _validate$errors2;
+
+  const validate = createRoleImportValidator();
+
+  if (validate(maybeRoles)) {
+    return maybeRoles;
+  }
+
+  throw new SchemaValidationError('Roles were invalid', (_validate$errors2 = validate.errors) === null || _validate$errors2 === void 0 ? void 0 : _validate$errors2.map(formatError));
+}
+/**
+ * Wrap the version-validator logic in a simple fn to bring it more inline with
+ * an ajv compiled validator.
+ */
+
+function getProjectSchemaValidation(schemaVersion) {
+  const validation = findValidator(schemaVersion);
+  return maybeSchema => {
+    if (!validation) {
+      return {
+        errors: [{
+          path: [],
+          type: 'invalidVersion',
+          message: 'Invalid schema version'
+        }],
+        schema: undefined,
+        valid: false
+      };
+    }
+
+    return validation.validate(maybeSchema);
+  };
+}
+/**
+ * Only use when validating an imported schema!
+ *
+ * New style validation for parity with the `validateRoleImport` fn. Returns
+ * a valid, and potentially cleaned `AnyProjectSchema` or throws a
+ * `SchemaValidationError`.
+ */
+
+
+export function validateProjectSchemaImport(maybeSchema) {
+  const validate = getProjectSchemaValidation(maybeSchema === null || maybeSchema === void 0 ? void 0 : maybeSchema.schemaVersion);
+  const validateResult = validate(maybeSchema);
+
+  if (validateResult.valid) {
+    return maybeSchema;
+  }
+
+  throw new SchemaValidationError('ProjectSchema could not be validated', validateResult.errors);
+}