@takeshape/schema 7.194.0

package/lib/validate.js

@@ -0,0 +1,823 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addProjectSchemasToAjv = addProjectSchemasToAjv;
+exports.formatError = formatError;
+exports.validateSchema = validateSchema;
+exports.ensureValidV3Schema = ensureValidV3Schema;
+exports.ensureValidLatestSchema = ensureValidLatestSchema;
+exports.validateRoleInput = validateRoleInput;
+exports.validateRoleImport = validateRoleImport;
+exports.validateProjectSchemaImport = validateProjectSchemaImport;
+
+var _jsonSchema = require("@takeshape/json-schema");
+
+var _errors = require("@takeshape/errors");
+
+var _coerce3 = _interopRequireDefault(require("semver/functions/coerce"));
+
+var _eq = _interopRequireDefault(require("semver/functions/eq"));
+
+var _neq = _interopRequireDefault(require("semver/functions/neq"));
+
+var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));
+
+var _versions = require("./versions");
+
+var _workflows = require("./workflows");
+
+var _v = _interopRequireDefault(require("./schemas/project-schema/v1.0.0.json"));
+
+var _v2 = _interopRequireDefault(require("./schemas/project-schema/v3.0.0.json"));
+
+var _v3 = _interopRequireDefault(require("./schemas/project-schema/v3.1.0.json"));
+
+var _v4 = _interopRequireDefault(require("./schemas/project-schema/v3.2.0.json"));
+
+var _v5 = _interopRequireDefault(require("./schemas/project-schema/v3.3.0.json"));
+
+var _v6 = _interopRequireDefault(require("./schemas/project-schema/v3.4.0.json"));
+
+var _v7 = _interopRequireDefault(require("./schemas/project-schema/v3.5.0.json"));
+
+var _v8 = _interopRequireDefault(require("./schemas/project-schema/v3.5.1.json"));
+
+var _v9 = _interopRequireDefault(require("./schemas/project-schema/v3.6.0.json"));
+
+var _metaSchemaV = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v1.0.0.json"));
+
+var _metaSchemaV2 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.0.0.json"));
+
+var _metaSchemaV3 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.1.0.json"));
+
+var _metaSchemaV4 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.2.0.json"));
+
+var _metaSchemaV5 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.3.0.json"));
+
+var _metaSchemaV6 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.4.0.json"));
+
+var _metaSchemaV7 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.5.0.json"));
+
+var _metaSchemaV8 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.5.1.json"));
+
+var _metaSchemaV9 = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.6.0.json"));
+
+var _authSchemas = _interopRequireDefault(require("./schemas/auth-schemas.json"));
+
+var _resolvers = require("./resolvers");
+
+var _schemaUtil = require("./schema-util");
+
+var _builtinSchema = require("./builtin-schema");
+
+var _templateShapes = require("./template-shapes");
+
+var _types = require("./types");
+
+var _refs = require("./refs");
+
+var _scalars = require("./scalars");
+
+var _unions = require("./unions");
+
+var _enum = require("./enum");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 === _versions.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 !== _workflows.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 !== _workflows.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 (!_resolvers.resolverList.includes(resolver.name)) {
+      errors.push({
+        type: 'notFound',
+        path: basePath.concat(['name']),
+        message: `Invalid resolver name "${resolver.name}"`
+      });
+    }
+
+    if (_resolvers.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 ((0, _types.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
+  } = (0, _templateShapes.parseReturnShape)(projectSchema, operation.shape);
+
+  if (template && !(0, _templateShapes.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(_builtinSchema.builtInShapes), ..._scalars.scalars];
+
+function getModelShapeIds(shapes) {
+  return Object.values(shapes).filter(shape => shape.model).map(shape => shape.id);
+}
+
+const builtInModelShapeIds = getModelShapeIds(_builtinSchema.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 = (0, _schemaUtil.getAllRefsInShapes)(projectSchema);
+
+  if (refs.length > 0) {
+    refs.forEach(item => {
+      const shapeName = (0, _refs.refItemToShapeName)(item);
+
+      if (!shapeNames.has(shapeName)) {
+        errors.push({
+          type: 'notFound',
+          path: item.path,
+          message: `Invalid ref "${(0, _refs.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]);
+  (0, _schemaUtil.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 = [];
+  (0, _schemaUtil.visitShapeProperties)(projectSchema.shapes, (schema, path) => {
+    const oneOfPath = schema.items ? ['items', 'oneOf'] : ['oneOf'];
+    schema = schema.items ? schema.items : schema;
+
+    if (schema.oneOf) {
+      if ((0, _unions.isUnionSchema)(schema)) {
+        const modelsReferenced = (0, _unions.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 (!(0, _enum.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;
+}
+
+function addProjectSchemasToAjv(ajv) {
+  ajv.addSchema(_metaSchemaV.default);
+  ajv.addSchema(_v.default);
+  ajv.addSchema(_metaSchemaV2.default);
+  ajv.addSchema(_v2.default);
+  ajv.addSchema(_metaSchemaV3.default);
+  ajv.addSchema(_v3.default);
+  ajv.addSchema(_metaSchemaV4.default);
+  ajv.addSchema(_v4.default);
+  ajv.addSchema(_metaSchemaV5.default);
+  ajv.addSchema(_v5.default);
+  ajv.addSchema(_metaSchemaV6.default);
+  ajv.addSchema(_v6.default);
+  ajv.addSchema(_metaSchemaV7.default);
+  ajv.addSchema(_v7.default);
+  ajv.addSchema(_metaSchemaV8.default);
+  ajv.addSchema(_v8.default);
+  ajv.addSchema(_metaSchemaV9.default);
+  ajv.addSchema(_v9.default);
+  return ajv;
+}
+
+const bracketRegex = /\['|']\./g;
+
+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 = (0, _jsonSchema.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 = (0, _schemaUtil.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: _v.default.$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: _v2.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.1.0',
+  schemaId: _v3.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.2.0',
+  schemaId: _v4.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.3.0',
+  schemaId: _v5.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.4.0',
+  schemaId: _v6.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.5.0',
+  schemaId: _v7.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.5.1',
+  schemaId: _v8.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}, {
+  version: '3.6.0',
+  schemaId: _v9.default.$id,
+
+  validate(schema, options) {
+    return validateV3X(this.schemaId, schema, options);
+  }
+
+}];
+
+function findValidator(schemaVersion) {
+  const schemaSemVer = (0, _coerce3.default)(schemaVersion !== null && schemaVersion !== void 0 ? schemaVersion : '1');
+  return validators.find(v => {
+    const validatorSemVer = (0, _coerce3.default)(v.version);
+    return validatorSemVer && schemaSemVer && (0, _eq.default)(validatorSemVer, schemaSemVer);
+  });
+}
+/**
+ * Validates a schema using a matching validation based on the `schemaVersion` property.
+ */
+
+
+function validateSchema(obj, options) {
+  if ((0, _isUndefined.default)(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);
+}
+
+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 ((0, _isUndefined.default)(schema)) {
+    throw new Error(`Invalid schema: schema is undefined`);
+  }
+
+  if ((0, _neq.default)('3.0.0', (_coerce = (0, _coerce3.default)(schema.schemaVersion)) !== null && _coerce !== void 0 ? _coerce : _versions.LEGACY_SCHEMA_VERSION)) {
+    throw new Error(`Expected schemaVersion: "3", got "${schema.schemaVersion}"`);
+  }
+
+  return schema;
+}
+
+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 ((0, _isUndefined.default)(schema)) {
+    throw new Error(`Invalid schema: schema is undefined`);
+  }
+
+  if ((0, _neq.default)(_versions.CURRENT_SCHEMA_VERSION, (_coerce2 = (0, _coerce3.default)(schema.schemaVersion)) !== null && _coerce2 !== void 0 ? _coerce2 : _versions.LEGACY_SCHEMA_VERSION)) {
+    throw new Error(`Expected schemaVersion: "${_versions.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 = (0, _jsonSchema.createAjv)({
+    useDefaults: true
+  });
+  const {
+    RoleInput,
+    ...definitions
+  } = _authSchemas.default.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.
+ */
+
+
+function validateRoleInput(maybeRoleInput) {
+  var _validate$errors;
+
+  const validate = createRoleInputValidator();
+
+  if (validate(maybeRoleInput)) {
+    return maybeRoleInput;
+  }
+
+  throw new _errors.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 = (0, _jsonSchema.createAjv)({
+    useDefaults: true
+  });
+  const {
+    RoleImport,
+    ...definitions
+  } = _authSchemas.default.definitions;
+  return validator.compile({
+    $id: 'RoleImport',
+    definitions,
+    ...RoleImport
+  });
+}
+/**
+ * Validates and returns a `RoleImport` array, which is a collection of `RoleInput`s.
+ */
+
+
+function validateRoleImport(maybeRoles) {
+  var _validate$errors2;
+
+  const validate = createRoleImportValidator();
+
+  if (validate(maybeRoles)) {
+    return maybeRoles;
+  }
+
+  throw new _errors.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`.
+ */
+
+
+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 _errors.SchemaValidationError('ProjectSchema could not be validated', validateResult.errors);
+}