@takeshape/schema 9.80.3 → 9.81.0

package/es/validate.js

@@ -31,10 +31,8 @@ import pMap from 'p-map';
 import { flatten } from 'lodash';
 import { isLatestProjectSchemaJSON } from './project-schema';
 const builtInShapeNames = new Set([...Object.keys(builtInShapes), ...scalars, 'object']);
-
 function findDuplicates(items) {
   const seen = {};
-
   for (const item of items) {
     if (seen[item.value]) {
       seen[item.value].push(item.path);
@@ -42,13 +40,11 @@ function findDuplicates(items) {
       seen[item.value] = [item.path];
     }
   }
-
   return Object.entries(seen).filter(entry => entry[1].length > 1).flatMap(entry => ({
     value: entry[0],
     paths: entry[1]
   }));
 }
-
 function checkShapeIds(shapes) {
   const items = Object.entries(shapes).map(entry => ({
     path: ['shapes', entry[0], 'id'],
@@ -60,7 +56,6 @@ function checkShapeIds(shapes) {
     message: `Shapes must have unique ids. "${dupe.value}" is not unique.`
   })));
 }
-
 function checkShapeNames(shapes) {
   Object.entries(shapes).map(entry => ({
     path: ['shapes', entry[0], 'id'],
@@ -72,7 +67,6 @@ function checkShapeNames(shapes) {
     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) => ({
@@ -86,7 +80,6 @@ function checkWorkflowStepNames(workflows) {
     })));
   });
 }
-
 function checkWorkflowStepKeys(workflows) {
   const items = Object.entries(workflows).flatMap(([name, workflow]) => workflow.steps.map((step, i) => ({
     path: ['workflows', name, 'steps', i, 'key'],
@@ -98,10 +91,8 @@ function checkWorkflowStepKeys(workflows) {
     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'],
@@ -109,16 +100,12 @@ function validateWorkflowVersion(projectSchema) {
       message: `apiVersion ${projectSchema.apiVersion} does not support workflows`
     });
   }
-
   return errors;
 }
-
 function validateWorkflows(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',
@@ -127,17 +114,13 @@ function validateWorkflows(projectSchema) {
       });
     }
   }
-
   return errors;
 }
-
 function getSemver(schemaVersion) {
   return coerce(schemaVersion) ?? LEGACY_SCHEMA_VERSION;
 }
-
 function enumerateBasicResolvers(resolver, path) {
   const results = [];
-
   const visit = (resolver, path) => {
     if (isComposeResolver(resolver)) {
       resolver.compose.forEach((resolver, i) => {
@@ -147,35 +130,27 @@ function enumerateBasicResolvers(resolver, path) {
       results.push([resolver, path]);
     }
   };
-
   visit(resolver, path);
   return results;
-} // eslint-disable-next-line complexity
-
+}
 
+// eslint-disable-next-line complexity
 function validateResolver(projectSchema, basePath, baseResolver) {
   const errors = [];
-
   const isValidShapeName = shapeName => {
     var _shape$cache;
-
     if (!shapeName) {
       return false;
     }
-
     const shape = getShape(projectSchema, shapeName);
-
     if (shape !== null && shape !== void 0 && shape.model) {
       return true;
     }
-
     return Boolean((shape === null || shape === void 0 ? void 0 : (_shape$cache = shape.cache) === null || _shape$cache === void 0 ? void 0 : _shape$cache.enabled) && shape.loaders);
   };
-
   const delegateResolverMissingConfig = (parsed, resolver) => {
     if (parsed.serviceId === 'local') {
       const targetResolver = get(projectSchema, propertyRefItemToResolverPath(getNamespace, parsed));
-
       if (!isBasicResolver(targetResolver) && !isComposeResolver(targetResolver)) {
         return {
           type: 'notFound',
@@ -185,13 +160,10 @@ function validateResolver(projectSchema, basePath, baseResolver) {
       }
     }
   };
-
   const getNamespace = createGetNamespace(projectSchema);
-
   for (const [resolver, path] of enumerateBasicResolvers(baseResolver, basePath)) {
     if (isBasicResolver(resolver)) {
       var _projectSchema$servic;
-
       if ('service' in resolver && resolver.service !== 'shapedb' && resolver.service !== 'takeshape' && !((_projectSchema$servic = projectSchema.services) !== null && _projectSchema$servic !== void 0 && _projectSchema$servic[resolver.service])) {
         errors.push({
           type: 'notFound',
@@ -199,12 +171,10 @@ function validateResolver(projectSchema, basePath, baseResolver) {
           message: `Invalid service "${resolver.service}"`
         });
       }
-
       if (resolver.shapeName) {
         const {
           shapeName
         } = resolver;
-
         if (!isValidShapeName(shapeName)) {
           errors.push({
             type: 'notFound',
@@ -213,13 +183,10 @@ function validateResolver(projectSchema, basePath, baseResolver) {
           });
         }
       }
-
       if (resolver.name === 'delegate') {
         const parsed = parsePropertyRef(resolver.to);
-
         if (parsed) {
           const error = delegateResolverMissingConfig(parsed, resolver);
-
           if (error) {
             errors.push(error);
           }
@@ -239,41 +206,31 @@ function validateResolver(projectSchema, basePath, baseResolver) {
       });
     }
   }
-
   return errors;
 }
-
 function validateLocalQueryConfig(projectSchema, query, operation, name) {
   const location = operation === 'query' ? 'queries' : 'mutations';
   return validateResolver(projectSchema, [location, name, 'resolver'], query.resolver);
 }
-
 const operationProps = [['query', 'queries'], ['mutation', 'mutations']];
-
 function validateLocalQueryConfigs(projectSchema) {
   const errors = [];
-
   for (const [operation, prop] of operationProps) {
     for (const name of Object.keys(projectSchema[prop])) {
       errors.push(...validateLocalQueryConfig(projectSchema, projectSchema[prop][name], operation, name));
     }
   }
-
   return errors;
 }
-
 function allowDisconnected(context, status) {
   return Boolean(context.allowDisconnectedLayers) && status !== 'notAvailable';
 }
-
 function isValidShapeReference(context, layerState, shapeName) {
   if (layerState.status !== 'ok') {
     return allowDisconnected(context, layerState.status);
   }
-
   return Boolean(layerState.schema.shapes[shapeName]);
 }
-
 async function validateResolverReferences(context, projectSchema, basePath, baseResolver) {
   const errors = [];
   await pMap(enumerateBasicResolvers(baseResolver, basePath), async ([resolver, path]) => {
@@ -285,7 +242,6 @@ async function validateResolverReferences(context, projectSchema, basePath, base
       const prop = resolver.name === 'graphql:query' ? 'queries' : 'mutations';
       const layerState = await context.resolveLayer(service);
       const valid = layerState.status === 'ok' ? Boolean(layerState.schema[prop][fieldName]) : allowDisconnected(context, layerState.status);
-
       if (!valid) {
         const operation = resolver.name === 'graphql:query' ? 'query' : 'mutation';
         errors.push({
@@ -296,11 +252,9 @@ async function validateResolverReferences(context, projectSchema, basePath, base
       }
     } else if (resolver.name === 'delegate') {
       const ref = parsePropertyRef(resolver.to);
-
       if (ref && ref.serviceId !== 'local') {
         const layerState = await context.resolveLayer(ref.serviceId);
         const valid = layerState.status === 'ok' ? Boolean(get(layerState.schema, propertyRefItemToPath(value(''), ref))) : allowDisconnected(context, layerState.status);
-
         if (!valid) {
           errors.push({
             type: 'notFound',
@@ -313,7 +267,6 @@ async function validateResolverReferences(context, projectSchema, basePath, base
   });
   return errors;
 }
-
 async function validateQueryConfig(context, projectSchema, {
   query,
   name,
@@ -322,16 +275,12 @@ async function validateQueryConfig(context, projectSchema, {
   const location = operation === 'query' ? 'queries' : 'mutations';
   return validateResolverReferences(context, projectSchema, [location, name, 'resolver'], query.resolver);
 }
-
 async function validateQueryConfigs(context, projectSchema) {
   const isLessThanV3_9_0 = lt(getSemver(projectSchema.schemaVersion), '3.9.0');
-
   if (isLessThanV3_9_0) {
     return [];
   }
-
   const promises = [];
-
   for (const [operation, prop] of operationProps) {
     for (const name of Object.keys(projectSchema[prop])) {
       promises.push(validateQueryConfig(context, projectSchema, {
@@ -341,16 +290,12 @@ async function validateQueryConfigs(context, projectSchema) {
       }));
     }
   }
-
   return flatten(await Promise.all(promises));
 }
-
 function listShapeJoins(projectSchema) {
   const joins = [];
-
   for (const shapeKey of Object.keys(projectSchema.shapes)) {
     const shape = projectSchema.shapes[shapeKey];
-
     if (shape.joins) {
       for (const joinRef of Object.keys(shape.joins)) {
         const join = shape.joins[joinRef];
@@ -362,16 +307,12 @@ function listShapeJoins(projectSchema) {
       }
     }
   }
-
   return joins;
 }
-
 function validateLocalShapeJoinRef(projectSchema, item) {
   const refItem = atRefToRefItem(projectSchema, item.ref);
-
   if (refItem.serviceKey === 'local') {
     const shape = refItemToShape(projectSchema, refItem);
-
     if (!shape) {
       return [{
         type: 'notFound',
@@ -380,21 +321,16 @@ function validateLocalShapeJoinRef(projectSchema, item) {
       }];
     }
   }
-
   return [];
 }
-
 function validateLocalShapeJoins(projectSchema) {
   return listShapeJoins(projectSchema).flatMap(item => validateLocalShapeJoinRef(projectSchema, item).concat(validateResolver(projectSchema, item.path.concat('resolver'), item.join.resolver)));
 }
-
 async function validateShapeJoinRef(context, projectSchema, item) {
   const refItem = atRefToRefItem(projectSchema, item.ref);
-
   if (refItem) {
     const layer = await context.resolveLayer(refItem.serviceKey);
     const valid = isValidRef(context, projectSchema, layer, refItem);
-
     if (!valid) {
       return [{
         type: 'notFound',
@@ -403,32 +339,24 @@ async function validateShapeJoinRef(context, projectSchema, item) {
       }];
     }
   }
-
   return [];
 }
-
 async function validateShapeJoins(context, projectSchema) {
   const promises = [];
-
   for (const item of listShapeJoins(projectSchema)) {
     promises.push(validateShapeJoinRef(context, projectSchema, item), validateResolverReferences(context, projectSchema, item.path, item.join.resolver));
   }
-
   return flatten(await Promise.all(promises));
 }
-
 function validateShapeLoaders(projectSchema, shape) {
   const errors = [];
-
   if (shape.loaders) {
     const getNamespace = createGetNamespace(projectSchema);
     const listLoader = shape.loaders.list;
-
     if (listLoader) {
       ensureArray(listLoader).forEach((config, i) => {
         const ref = parsePropertyRef(config.query);
         const query = ref && get(projectSchema, propertyRefItemToPath(getNamespace, ref));
-
         if (!query) {
           errors.push({
             path: Array.isArray(listLoader) ? ['shapes', shape.name, 'loaders', 'list', i, 'query'] : ['shapes', shape.name, 'loaders', 'list', 'query'],
@@ -438,13 +366,10 @@ function validateShapeLoaders(projectSchema, shape) {
         }
       });
     }
-
     const getLoader = shape.loaders.get;
-
     if (getLoader) {
       const ref = parsePropertyRef(getLoader.query);
       const query = ref && get(projectSchema, propertyRefItemToPath(getNamespace, ref));
-
       if (!query) {
         errors.push({
           path: ['shapes', shape.name, 'loaders', 'get', 'query'],
@@ -454,10 +379,8 @@ function validateShapeLoaders(projectSchema, shape) {
       }
     }
   }
-
   return errors;
 }
-
 function visitProperties(projectSchema, callback) {
   JSONPath('$..properties.*', projectSchema, (property, _type, {
     path: propertyPath
@@ -465,28 +388,22 @@ function visitProperties(projectSchema, callback) {
     callback(property, propertyPath.slice(3, -2).split(`']['`));
   }, undefined);
 }
-
 function validateIndexedShapes(projectSchema) {
   const errors = [];
   const {
     shapes
   } = projectSchema;
-
   for (const shape of Object.values(shapes)) {
     const newErrors = validateShapeLoaders(projectSchema, shape);
-
     if (newErrors.length) {
       errors.push(...newErrors);
     }
   }
-
   let nestedCount = 0;
   visitProperties(projectSchema, (property, propertyPath) => {
     const indexed = property['@indexed'];
-
     if (isRecord(indexed) && indexed.nested) {
       nestedCount += 1;
-
       if (property.type !== 'array') {
         errors.push({
           path: propertyPath,
@@ -496,7 +413,6 @@ function validateIndexedShapes(projectSchema) {
       }
     }
   });
-
   if (nestedCount > 50) {
     errors.push({
       path: ['shapes'],
@@ -504,24 +420,20 @@ function validateIndexedShapes(projectSchema) {
       message: `${nestedCount} nested indexes found`
     });
   }
-
   return errors;
 }
+
 /**
  * Verify the path has an allOf schema and not just prop named "allOf"
  */
-
-
 function isAllOfPath(path) {
   const index = path.indexOf('allOf');
   return index !== -1 && isIntegerLike(path[index + 1]);
 }
-
 function validateLocalRefs(projectSchema) {
   const errors = [];
   const shapeNames = new Set([...builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
   const refs = getAllRefs(projectSchema).filter(item => !item.isForeign);
-
   for (const item of refs) {
     if (item.template && !isValidTemplate(item.template)) {
       errors.push({
@@ -530,9 +442,7 @@ function validateLocalRefs(projectSchema) {
         message: `Invalid template "${item.template}"`
       });
     }
-
     const shapeName = refItemToShapeName(item);
-
     if (!shapeNames.has(shapeName)) {
       const invalidRef = get(projectSchema, item.path);
       const path = invalidRef.items ? [...item.path, 'items', '@ref'] : item.path;
@@ -542,9 +452,9 @@ function validateLocalRefs(projectSchema) {
         path,
         message: `Invalid ref "${ref}"`
       });
-    } // Make sure refs inside allOf don't refer to their own Shape
-
+    }
 
+    // Make sure refs inside allOf don't refer to their own Shape
     if (item.path[1] === shapeName && isAllOfPath(item.path)) {
       errors.push({
         type: 'conflict',
@@ -552,11 +462,9 @@ function validateLocalRefs(projectSchema) {
         message: `allOf cannot be self-referential`
       });
     }
-
     const parentPath = initial(item.path);
     const parentSchema = get(projectSchema, parentPath);
     const propName = last(item.path);
-
     if (propName === '@ref' && parentSchema.$ref) {
       errors.push({
         type: 'conflict',
@@ -565,10 +473,8 @@ function validateLocalRefs(projectSchema) {
       });
     }
   }
-
   return errors;
 }
-
 function isValidRef(context, projectSchema, layer, item) {
   const {
     serviceKey: layerId
@@ -577,7 +483,6 @@ function isValidRef(context, projectSchema, layer, item) {
   const localShapeExists = Boolean(projectSchema.shapes[shapeName]) || builtInShapeNames.has(shapeName);
   return layerId === 'local' ? localShapeExists : localShapeExists || isValidShapeReference(context, layer, shapeName);
 }
-
 async function validateRefs(context, projectSchema) {
   const {
     resolveLayer
@@ -585,15 +490,12 @@ async function validateRefs(context, projectSchema) {
   const errors = [];
   const refs = getAllRefs(projectSchema);
   const layerIds = new Set();
-
   for (const item of refs) {
     if (item.serviceKey !== 'local') {
       layerIds.add(item.serviceKey);
     }
   }
-
   const layersById = Object.fromEntries(await pMap(layerIds, async layerId => [layerId, await resolveLayer(layerId)]));
-
   for (const item of refs) {
     if (item.template && !isValidTemplate(item.template)) {
       errors.push({
@@ -602,12 +504,10 @@ async function validateRefs(context, projectSchema) {
         message: `Invalid template "${item.path}"`
       });
     }
-
     const {
       serviceKey: layerId
     } = item;
     const valid = isValidRef(context, projectSchema, layersById[layerId], item);
-
     if (!valid) {
       errors.push({
         type: 'notFound',
@@ -616,10 +516,8 @@ async function validateRefs(context, projectSchema) {
       });
     }
   }
-
   return errors;
 }
-
 function visitShapePropertiesJson(projectSchema, callback) {
   JSONPath('shapes.*.schema.properties.*', projectSchema, (property, _type, {
     path: propertyPath
@@ -627,16 +525,13 @@ function visitShapePropertiesJson(projectSchema, callback) {
     callback(property, propertyPath.slice(3, -2).split(`']['`));
   }, undefined);
 }
-
 function validateDirectives(projectSchema) {
   const errors = [];
   visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
     const resolver = property['@resolver'];
-
     if (resolver) {
       const propPath = propertyPath.concat('@resolver');
       const resolverErrors = validateResolver(projectSchema, propPath, resolver);
-
       if (resolverErrors) {
         errors.push(...resolverErrors);
       }
@@ -644,7 +539,6 @@ function validateDirectives(projectSchema) {
   });
   return errors;
 }
-
 function validateOneOfs(projectSchema) {
   const errors = [];
   visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
@@ -652,7 +546,6 @@ function validateOneOfs(projectSchema) {
     const relationship = getRelationship(property);
     const schema = property.items ? property.items : property;
     const isUnion = isUnionSchema(schema);
-
     if (schema.oneOf && !relationship && !isUnion && !isEnumLikeSchema(schema)) {
       errors.push({
         type: 'conflict',
@@ -660,7 +553,6 @@ function validateOneOfs(projectSchema) {
         message: `Invalid oneOf must contain only @ref or title + enum/const schemas`
       });
     }
-
     if (isUnion && schema.oneOf.length !== uniqBy(schema.oneOf, refSchema => getRefShapeName(projectSchema, refSchema)).length) {
       errors.push({
         type: 'conflict',
@@ -671,14 +563,12 @@ function validateOneOfs(projectSchema) {
   });
   return errors;
 }
-
 function validateLocales(projectSchema) {
   const {
     locales,
     defaultLocale
   } = projectSchema;
   const errors = [];
-
   if (locales && !locales.includes(defaultLocale)) {
     errors.push({
       type: 'notFound',
@@ -686,27 +576,21 @@ function validateLocales(projectSchema) {
       message: `Default locale "${defaultLocale}" missing from locales`
     });
   }
-
   return errors;
 }
-
 const importantFields = ['type', '@ref', 'allOf', 'oneOf', 'anyOf', 'extends', 'items', '@tag'];
-
 function isSchemaEqual(a, b) {
   return isEqual(pick(a, importantFields), pick(b, importantFields));
 }
-
 function matchesInterface(shape, interfaceShape, path) {
   const errors = [];
   const {
     schema
   } = shape;
   const interfaceSchema = interfaceShape.schema;
-
   for (const name of Object.keys(interfaceSchema.properties)) {
     const propSchema = schema.properties[name];
     const interfacePropSchema = interfaceSchema.properties[name];
-
     if (!propSchema) {
       errors.push({
         type: 'notFound',
@@ -721,10 +605,8 @@ function matchesInterface(shape, interfaceShape, path) {
       });
     } else {
       var _schema$required, _interfaceSchema$requ;
-
       const propRequired = Boolean((_schema$required = schema.required) === null || _schema$required === void 0 ? void 0 : _schema$required.includes(name));
       const interfacePropRequired = Boolean((_interfaceSchema$requ = interfaceSchema.required) === null || _interfaceSchema$requ === void 0 ? void 0 : _interfaceSchema$requ.includes(name));
-
       if (interfacePropRequired !== propRequired) {
         errors.push({
           type: 'conflict',
@@ -734,14 +616,11 @@ function matchesInterface(shape, interfaceShape, path) {
       }
     }
   }
-
   return errors;
 }
-
 function validateShapeImplementsInterface(projectSchema, shape, interfaceShapeName, path) {
   const errors = [];
   const interfaceShape = projectSchema.shapes[interfaceShapeName];
-
   if (!interfaceShape) {
     errors.push({
       type: 'notFound',
@@ -754,24 +633,20 @@ function validateShapeImplementsInterface(projectSchema, shape, interfaceShapeNa
       path,
       message: `"${shape.name}" cannot implement non-interface "${interfaceShape.name}"`
     });
-  } else if (isExtendsSchema(shape.schema)) {// TODO stricter extends validation needs https://app.shortcut.com/takeshape/story/9783/use-service-schemas-during-schema-validation
+  } else if (isExtendsSchema(shape.schema)) {
+    // TODO stricter extends validation needs https://app.shortcut.com/takeshape/story/9783/use-service-schemas-during-schema-validation
   } else if (isObjectSchema(shape.schema) && isObjectSchema(interfaceShape.schema)) {
     const matchErrors = matchesInterface(shape, interfaceShape, ['shapes', shape.name, 'schema', 'properties']);
-
     if (matchErrors.length) {
       errors.push(...matchErrors);
     }
   }
-
   return errors;
 }
-
 function validateInterfaceImplementations(projectSchema) {
   const errors = [];
-
   for (const shape of Object.values(projectSchema.shapes)) {
     var _shape$interfaces;
-
     if ((_shape$interfaces = shape.interfaces) !== null && _shape$interfaces !== void 0 && _shape$interfaces.length) {
       if (!isObjectSchema(shape.schema) && !isExtendsSchema(shape.schema)) {
         return [{
@@ -780,24 +655,20 @@ function validateInterfaceImplementations(projectSchema) {
           message: `"${shape.name}" must have an object or extends schema to implement interfaces`
         }];
       }
-
       for (let i = 0; i < shape.interfaces.length; i++) {
         const path = ['shapes', shape.name, 'interfaces', i];
         const interfaceErrors = validateShapeImplementsInterface(projectSchema, shape, shape.interfaces[i], path);
-
         if (interfaceErrors.length) {
           errors.push(...interfaceErrors);
         }
       }
     }
   }
-
   return errors;
 }
-
 function validateInterfaces(projectSchema) {
-  const errors = []; // Validate interface shapes must be an object schema with at least one property
-
+  const errors = [];
+  // Validate interface shapes must be an object schema with at least one property
   for (const shape of Object.values(projectSchema.shapes)) {
     if (shape.type === 'interface') {
       if (shape.model) {
@@ -823,27 +694,21 @@ function validateInterfaces(projectSchema) {
       }
     }
   }
-
   return errors;
 }
-
 export function formatError(error) {
   let pathStr = error.instancePath;
   let message = 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}"`;
   }
-
   if ('allowedValues' in error.params) {
     message = `${message} "${error.params.allowedValues.join('", "')}"`;
   }
-
   const path = pathStr === '' ? [] : pathStr.substr(1).split(/\.|\/|\['|']\./);
   return {
     type: 'json',
@@ -851,37 +716,29 @@ export function formatError(error) {
     path
   };
 }
-
 function isValidateReferencesContext(context) {
   return Boolean(context.resolveLayer);
 }
-
 const ajv = createAjv();
-
 function validateStructure(schemaVersion, context, schema, ref) {
   var _coerce, _ajv$errors;
-
   const versionStr = (_coerce = coerce(schemaVersion)) === null || _coerce === void 0 ? void 0 : _coerce.format();
   const relevantSchemas = allProjectSchemas.filter(metaSchema => metaSchema.$id.endsWith(`v${versionStr}#`));
-
   for (const relevantSchema of relevantSchemas) {
     if (!ajv.getSchema(relevantSchema.$id)) {
       ajv.addSchema(relevantSchema);
     }
   }
-
   ajv.validate(`https://schema.takeshape.io/project-schema/v${versionStr}#${ref ?? ''}`, schema);
   let errors = ((_ajv$errors = ajv.errors) === null || _ajv$errors === void 0 ? void 0 : _ajv$errors.map(formatError)) ?? [];
   const {
     suppressErrorPaths
   } = context;
-
   if (errors.length && suppressErrorPaths) {
     errors = errors.filter(error => {
       return !suppressErrorPaths.includes(error.path.join('.'));
     });
   }
-
   if (errors.length) {
     return {
       valid: false,
@@ -889,25 +746,21 @@ function validateStructure(schemaVersion, context, schema, ref) {
       errors
     };
   }
-
   return {
     valid: true,
     schema: schema,
     errors: undefined
   };
 }
-
 function formatValidationResult(context, errors, schema) {
   const {
     suppressErrorPaths
   } = context;
-
   if (suppressErrorPaths) {
     errors = errors.filter(error => {
       return !suppressErrorPaths.includes(error.path.join('.'));
     });
   }
-
   return errors.length ? {
     valid: false,
     schema: undefined,
@@ -918,18 +771,15 @@ function formatValidationResult(context, errors, schema) {
     errors: undefined
   };
 }
-
 function validateSyntax(context, schema) {
   let errors = [];
   errors = errors.concat(checkShapeNames(schema.shapes)).concat(checkShapeIds(schema.shapes)).concat(validateWorkflows(schema)).concat(validateLocalQueryConfigs(schema)).concat(validateLocalRefs(schema)).concat(validateLocalShapeJoins(schema)).concat(validateDirectives(schema)).concat(validateLocales(schema)).concat(checkWorkflowStepNames(schema.workflows)).concat(checkWorkflowStepKeys(schema.workflows)).concat(validateOneOfs(schema)).concat(validateIndexedShapes(schema)).concat(validateInterfaces(schema)).concat(validateInterfaceImplementations(schema));
   return formatValidationResult(context, errors, schema);
 }
-
 async function validateReferences(context, schema) {
   const errors = flatten(await Promise.all([validateRefs(context, schema), validateQueryConfigs(context, schema), validateShapeJoins(context, schema)]));
   return formatValidationResult(context, errors, schema);
 }
-
 const schemaUndefinedResult = {
   valid: false,
   schema: undefined,
@@ -948,65 +798,51 @@ const invalidVersionResult = {
     message: 'Unknown schema version'
   }]
 };
-
 function normalizeSchemaVersion(obj) {
   if (isRecord(obj)) {
     return typeof obj.schemaVersion === 'string' ? obj.schemaVersion : '1';
   }
 }
-
 export function validateSchemaSyntax(obj, options = {}) {
   if (isUndefined(obj)) {
     return schemaUndefinedResult;
   }
-
   const schemaVersion = normalizeSchemaVersion(obj);
-
   if (!schemaVersion) {
     return invalidVersionResult;
   }
-
   return validateStructure(schemaVersion, options, obj);
 }
+
 /**
  * Validates a schema using a matching validation based on the `schemaVersion` property.
  */
-
 export async function validateSchema(context, obj) {
   if (isUndefined(obj)) {
     return schemaUndefinedResult;
   }
-
   const contextWithDefaults = {
     allowDisconnectedLayers: true,
     ...context
   };
   const schemaVersion = normalizeSchemaVersion(obj);
-
   if (!schemaVersion) {
     return invalidVersionResult;
   }
-
   const structuralValidation = validateStructure(schemaVersion, contextWithDefaults, obj);
-
   if (!structuralValidation.valid) {
     return structuralValidation;
   }
-
   const {
     schema
   } = structuralValidation;
-
   if (!isLatestProjectSchemaJSON(schema)) {
     return invalidVersionResult;
   }
-
   const syntaxValidation = validateSyntax(contextWithDefaults, schema);
-
   if (!syntaxValidation.valid || !isValidateReferencesContext(contextWithDefaults)) {
     return syntaxValidation;
   }
-
   return validateReferences(contextWithDefaults, schema);
 }
 export function ensureValidLatestSchemaSyntax(obj) {
@@ -1015,26 +851,22 @@ export function ensureValidLatestSchemaSyntax(obj) {
     schema,
     errors
   } = validateSchemaSyntax(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, coerce(schema.schemaVersion) ?? 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
@@ -1049,28 +881,24 @@ function createRoleInputValidator() {
     ...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
@@ -1085,23 +913,18 @@ function createRoleImportValidator() {
     ...RoleImport
   });
 }
+
 /**
  * Validates and returns a `RoleImport` array, which is a collection of `RoleInput`s.
  */
-
-
 export function ensureValidRoleImport(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));
 }
-
 /**
  * Only use when validating an imported schema! ignore fields optional when importing
  */
@@ -1110,19 +933,17 @@ export function validateProjectSchemaImport(maybeSchema) {
     suppressErrorPaths: [...projectSchemaImportOptionalProps, ...legacyProjectSchemaImportOptionalProps]
   });
 }
+
 /**
  * Only use when validating an imported schema!
  *
  * New style validation for parity with the `validateRoleImport` fn. Returns
  * a valid, clean `ImportProjectSchema` or throws a `SchemaValidationError`.
  */
-
 export function ensureValidProjectSchemaImport(maybeSchema) {
   const validateResult = validateProjectSchemaImport(maybeSchema);
-
   if (validateResult.valid) {
     return validateResult.schema;
   }
-
   throw new SchemaValidationError('ProjectSchema could not be validated', validateResult.errors);
 }