@takeshape/schema 9.32.3 → 9.33.2

package/es/validate.js

@@ -12,16 +12,16 @@ import { CURRENT_SCHEMA_VERSION, LEGACY_SCHEMA_VERSION, LEGACY_API_VERSION } fro
 import { defaultWorkflow } from './workflows';
 import { allProjectSchemas } from './schemas';
 import authSchemas from './schemas/auth-schemas.json';
-import { getAllNamespaceShapes, getAllRefsInShapes } from './schema-util';
+import { getAllRefs } from './schema-util';
 import { builtInShapes } from './builtin-schema';
 import { isValidTemplate } from './template-shapes';
 import { isBasicResolver, isComposeResolver, isExtendsSchema, isObjectSchema } from './types/utils';
-import { refItemToAtRef, refItemToShapeName, parseReturnShape, getRefShapeName, parsePropertyRef, propertyRefItemToResolverPath, createGetNamespace } from './refs';
+import { refItemToShapeName, getRefShapeName, parsePropertyRef, propertyRefItemToResolverPath, createGetNamespace, propertyRefItemToPath } from './refs';
 import { scalars } from './scalars';
 import { isUnionSchema } from './unions';
 import { isEnumLikeSchema } from './enum';
 import metaSchemaV3_9_0 from './schemas/project-schema/meta-schema-v3.9.0.json';
-import { ensureArray, isIntegerLike, isRecord } from '@takeshape/util';
+import { ensureArray, isIntegerLike, isRecord, value } from '@takeshape/util';
 import forOwn from 'lodash/forOwn';
 import uniqBy from 'lodash/uniqBy';
 import initial from 'lodash/initial';
@@ -32,6 +32,9 @@ import gte from 'semver/functions/gte';
 import size from 'lodash/size';
 import isEqual from 'lodash/isEqual';
 import pick from 'lodash/pick';
+import pMap from 'p-map';
+import { flatten } from 'lodash';
+const builtInShapeNames = new Set([...Object.keys(builtInShapes), ...scalars, 'object']);
 
 function findDuplicates(items) {
   const seen = {};
@@ -166,7 +169,24 @@ function getSemver(schemaVersion) {
   return coerce(schemaVersion) ?? LEGACY_SCHEMA_VERSION;
 }
 
-function validateResolver(projectSchema, basePath, resolver) {
+function enumerateBasicResolvers(resolver, path) {
+  const results = [];
+
+  const visit = (resolver, path) => {
+    if (isComposeResolver(resolver)) {
+      resolver.compose.forEach((resolver, i) => {
+        visit(resolver, [...path, i]);
+      });
+    } else {
+      results.push([resolver, path]);
+    }
+  };
+
+  visit(resolver, path);
+  return results;
+}
+
+function validateResolver(projectSchema, basePath, baseResolver) {
   const errors = [];
   /**
    * V3.9 Resolver name enums are the set used for earlier v3 validations
@@ -210,14 +230,14 @@ function validateResolver(projectSchema, basePath, resolver) {
   const isLessThanV3_9_0 = lt(getSemver(projectSchema.schemaVersion), '3.9.0');
   const getNamespace = createGetNamespace(projectSchema);
 
-  const validateBasicResolver = resolver => {
+  for (const [resolver, path] of enumerateBasicResolvers(baseResolver, basePath)) {
     if (isBasicResolver(resolver)) {
       var _projectSchema$servic;
 
       if ('service' in resolver && 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']),
+          path: path.concat(['service']),
           message: `Invalid service "${resolver.service}"`
         });
       }
@@ -225,7 +245,7 @@ function validateResolver(projectSchema, basePath, resolver) {
       if (isLessThanV3_9_0 && !isValidResolverNameV3_9_0(resolver.name)) {
         errors.push({
           type: 'notFound',
-          path: basePath.concat(['name']),
+          path: path.concat(['name']),
           message: `Invalid resolver name "${resolver.name}"`
         });
       }
@@ -241,7 +261,7 @@ function validateResolver(projectSchema, basePath, resolver) {
           if (!isValidShapeName(shapeName)) {
             errors.push({
               type: 'notFound',
-              path: basePath.concat(['options', 'model']),
+              path: path.concat(['options', 'model']),
               message: `Invalid Model Shape "${shapeName ?? ''}"`
             });
           }
@@ -256,7 +276,7 @@ function validateResolver(projectSchema, basePath, resolver) {
         if (!isValidShapeName(shapeName)) {
           errors.push({
             type: 'notFound',
-            path: basePath.concat(['shapeName']),
+            path: path.concat(['shapeName']),
             message: `Invalid Model Shape "${shapeName ?? ''}"`
           });
         }
@@ -274,7 +294,7 @@ function validateResolver(projectSchema, basePath, resolver) {
         } else {
           errors.push({
             type: 'conflict',
-            path: basePath.concat('to'),
+            path: path.concat('to'),
             message: `Unable to parse property ref "${resolver.to}"`
           });
         }
@@ -282,62 +302,115 @@ function validateResolver(projectSchema, basePath, resolver) {
     } else {
       errors.push({
         type: 'notFound',
-        path: basePath,
+        path,
         message: `Invalid resolver`
       });
     }
-  };
-
-  if (isComposeResolver(resolver)) {
-    resolver.compose.forEach(validateBasicResolver);
-  } else {
-    validateBasicResolver(resolver);
   }
 
   return errors;
-} // eslint-disable-next-line max-params
-
+}
 
-function validateQueryConfig(projectSchema, validReturnShapes, query, operation, name) {
+function validateLocalQueryConfig(projectSchema, query, operation, name) {
   const location = operation === 'query' ? 'queries' : 'mutations';
-  const errors = validateResolver(projectSchema, [location, name, 'resolver'], query.resolver);
-  const {
-    template,
-    shapeName
-  } = parseReturnShape(projectSchema, query.shape);
+  return validateResolver(projectSchema, [location, name, 'resolver'], query.resolver);
+}
 
-  if (template && !isValidTemplate(template)) {
-    errors.push({
-      type: 'notFound',
-      path: [location, name, 'shape'],
-      message: `Invalid template "${template}" for ${operation} "${name}"`
-    });
+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));
+    }
   }
 
-  if (!validReturnShapes.has(shapeName)) {
-    errors.push({
-      type: 'notFound',
-      path: [location, name, 'shape'],
-      message: `Invalid shape "${shapeName}" for ${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]) => {
+    if (resolver.name === 'graphql:query' || resolver.name === 'graphql:mutation') {
+      const {
+        service,
+        fieldName
+      } = resolver;
+      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({
+          type: 'notFound',
+          path: path.concat('fieldName'),
+          message: `Missing ${operation} "${resolver.fieldName}" in service layer "${service}"`
+        });
+      }
+    } 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',
+            path: path.concat('to'),
+            message: `Missing resolver config at property ref "${resolver.to}"`
+          });
+        }
+      }
+    }
+  });
   return errors;
 }
 
-function validateQueryConfigs(projectSchema, additionalShapeNames = builtInShapeNames) {
-  const validReturnShapes = new Set(Object.keys(projectSchema.shapes).concat(additionalShapeNames));
-  let errors = [];
+async function validateQueryConfig(context, projectSchema, {
+  query,
+  name,
+  operation
+}) {
+  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');
 
-  for (const name of Object.keys(projectSchema.queries)) {
-    errors = errors.concat(validateQueryConfig(projectSchema, validReturnShapes, projectSchema.queries[name], 'query', name));
+  if (isLessThanV3_9_0) {
+    return [];
   }
 
-  for (const name of Object.keys(projectSchema.mutations)) {
-    errors = errors.concat(validateQueryConfig(projectSchema, validReturnShapes, projectSchema.mutations[name], 'mutation', name));
+  const promises = [];
+
+  for (const [operation, prop] of operationProps) {
+    for (const name of Object.keys(projectSchema[prop])) {
+      promises.push(validateQueryConfig(context, projectSchema, {
+        query: projectSchema[prop][name],
+        operation,
+        name
+      }));
+    }
   }
 
-  return errors;
+  return flatten(await Promise.all(promises));
 }
 
 function validateIndexedShapeConfig(projectSchema, shapeName, config) {
@@ -419,8 +492,6 @@ function validateIndexedShapes(projectSchema) {
   return errors;
 }
 
-const builtInShapeNames = [...Object.keys(builtInShapes), ...scalars, 'object'];
-
 function getModelShapeIds(shapes) {
   return Object.values(shapes).filter(shape => shape.model).map(shape => shape.id);
 }
@@ -435,44 +506,94 @@ function isAllOfPath(path) {
   return index !== -1 && isIntegerLike(path[index + 1]);
 }
 
-function validateRefs(projectSchema, additionalShapeNames = builtInShapeNames) {
+function validateLocalRefs(projectSchema) {
   const errors = [];
-  const shapeNames = new Set([...additionalShapeNames, ...Object.keys(projectSchema.shapes)]);
-  const refs = getAllRefsInShapes(projectSchema);
+  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({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid template "${item.template}"`
+      });
+    }
 
-  if (refs.length > 0) {
-    refs.forEach(item => {
-      const shapeName = refItemToShapeName(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 (!shapeNames.has(shapeName)) {
+      errors.push({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid ref "${get(projectSchema, item.path)}"`
+      });
+    } // 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`
-        });
-      }
+    if (item.path[1] === shapeName && isAllOfPath(item.path)) {
+      errors.push({
+        type: 'conflict',
+        path: item.path,
+        message: `allOf cannot be self-referential`
+      });
+    }
 
-      const parentPath = initial(item.path);
-      const parentSchema = get(projectSchema, parentPath);
-      const propName = last(item.path);
+    const parentPath = initial(item.path);
+    const parentSchema = get(projectSchema, parentPath);
+    const propName = last(item.path);
 
-      if (propName === '@ref' && parentSchema.$ref) {
-        errors.push({
-          type: 'conflict',
-          path: parentPath,
-          message: `Ref cannot have both @ref and $ref`
-        });
-      }
-    });
+    if (propName === '@ref' && parentSchema.$ref) {
+      errors.push({
+        type: 'conflict',
+        path: parentPath,
+        message: `Ref cannot have both @ref and $ref`
+      });
+    }
+  }
+
+  return errors;
+}
+
+async function validateRefs(context, projectSchema) {
+  const {
+    resolveLayer
+  } = context;
+  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({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid template "${item.path}"`
+      });
+    }
+
+    const {
+      serviceKey: layerId
+    } = item;
+    const shapeName = refItemToShapeName(item);
+    const localShapeExists = Boolean(projectSchema.shapes[shapeName]) || builtInShapeNames.has(shapeName);
+    const valid = layerId === 'local' ? localShapeExists : localShapeExists || isValidShapeReference(context, layersById[layerId], shapeName);
+
+    if (!valid) {
+      errors.push({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid ref "${get(projectSchema, item.path)}"`
+      });
+    }
   }
 
   return errors;
@@ -739,9 +860,14 @@ export function formatError(error) {
     path
   };
 }
+
+function isValidateReferencesContext(context) {
+  return Boolean(context.resolveLayer);
+}
+
 const ajv = createAjv();
 
-function validateStructure(schemaVersion, schema, ref, options) {
+function validateStructure(schemaVersion, context, schema, ref) {
   var _coerce, _ajv$errors;
 
   const versionStr = (_coerce = coerce(schemaVersion)) === null || _coerce === void 0 ? void 0 : _coerce.format();
@@ -755,7 +881,9 @@ function validateStructure(schemaVersion, schema, ref, options) {
 
   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 = options === null || options === void 0 ? void 0 : options.suppressErrorPaths;
+  const {
+    suppressErrorPaths
+  } = context;
 
   if (errors.length && suppressErrorPaths) {
     errors = errors.filter(error => {
@@ -778,20 +906,10 @@ function validateStructure(schemaVersion, schema, ref, options) {
   };
 }
 
-function validateV3X(version, obj, options) {
-  const structuralValidation = validateStructure(version, obj, undefined, options);
-
-  if (!structuralValidation.valid) {
-    return structuralValidation;
-  }
-
-  const schema = obj;
-  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)).concat(validateIndexedShapes(schema)).concat(validateInterfaces(schema)).concat(validateInterfaceImplementations(schema));
-  const suppressErrorPaths = options === null || options === void 0 ? void 0 : options.suppressErrorPaths;
+function formatValidationResult(context, errors, schema) {
+  const {
+    suppressErrorPaths
+  } = context;
 
   if (suppressErrorPaths) {
     errors = errors.filter(error => {
@@ -810,132 +928,140 @@ function validateV3X(version, obj, options) {
   };
 }
 
-function validateV4X(version, obj, options) {
-  const structuralValidation = validateStructure(version, obj);
-
-  if (!structuralValidation.valid) {
-    return structuralValidation;
-  }
-
-  const schema = obj;
-
-  for (const [index, layerConfig] of Object.entries(schema.layers)) {
-    var _options$resolveLayer;
-
-    const layerId = typeof layerConfig === 'string' ? layerConfig : layerConfig.id;
-    const layer = options === null || options === void 0 ? void 0 : (_options$resolveLayer = options.resolveLayer) === null || _options$resolveLayer === void 0 ? void 0 : _options$resolveLayer.call(options, layerId);
-
-    if (layer) {
-      const results = validateStructure(version, layer, '/definitions/layerSchema');
-
-      if (!results.valid) {
-        return results;
-      }
-    } else {
-      return {
-        valid: false,
-        schema: undefined,
-        errors: [{
-          path: ['layers', index],
-          type: 'undefined',
-          message: `Layer with id is undefined`
-        }]
-      };
-    }
-  }
-
-  return {
-    valid: true,
-    schema,
-    errors: undefined
-  };
-}
-
 const validators = [{
   range: '^1.0.0',
 
-  validate(schemaVersion, obj) {
-    const structuralValidation = validateStructure(schemaVersion, obj);
-
-    if (!structuralValidation.valid) {
-      return structuralValidation;
-    }
-
+  validateSyntax(schemaVersion, context, obj) {
     const schemaV1 = obj;
     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
-    };
+    return formatValidationResult(context, errors, schemaV1);
   }
 
 }, {
   range: '^3.0.0',
-  validate: validateV3X
-}, {
-  range: '^4.0.0',
-  validate: validateV4X
+
+  validateSyntax(schemaVersion, context, obj) {
+    const schema = obj;
+    let errors = [];
+    errors = errors.concat(checkShapeNames(schema.shapes)).concat(checkShapeIds(schema.shapes)).concat(validateWorkflowsV3(schema)).concat(validateLocalQueryConfigs(schema)).concat(validateLocalRefs(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 validateReferences(schemaVersion, context, obj) {
+    const schema = obj;
+    const errors = flatten(await Promise.all([validateRefs(context, schema), validateQueryConfigs(context, schema)]));
+    return formatValidationResult(context, errors, schema);
+  }
+
 }];
 
 function findValidator(schemaVersion) {
-  const normalizedSchemaVersion = schemaVersion ?? '1';
-  const schemaSemVer = coerce(normalizedSchemaVersion);
+  const schemaSemVer = coerce(schemaVersion);
 
   if (schemaSemVer) {
     const validator = validators.find(v => satisfies(schemaSemVer, v.range));
 
     if (validator) {
-      return validator.validate.bind(null, normalizedSchemaVersion);
+      const {
+        validateSyntax,
+        validateReferences
+      } = validator;
+      return {
+        validateSyntax: validateSyntax.bind(null, schemaVersion),
+        ...(validateReferences ? {
+          validateReferences: validateReferences.bind(null, schemaVersion)
+        } : {})
+      };
     }
   }
 }
+
+const schemaUndefinedResult = {
+  valid: false,
+  schema: undefined,
+  errors: [{
+    path: [],
+    type: 'undefined',
+    message: 'Schema is undefined'
+  }]
+};
+const invalidVersionResult = {
+  valid: false,
+  schema: undefined,
+  errors: [{
+    path: [],
+    type: 'invalidVersion',
+    message: 'Unknown schema version'
+  }]
+};
+
+function normalizeSchemaVersion(schema) {
+  return schema.schemaVersion ?? '1';
+}
+
+export function validateSchemaSyntax(obj, options = {}) {
+  if (isUndefined(obj)) {
+    return schemaUndefinedResult;
+  }
+
+  const schema = obj;
+  const schemaVersion = normalizeSchemaVersion(schema);
+  const validator = findValidator(schemaVersion);
+
+  if (!validator) {
+    return invalidVersionResult;
+  }
+
+  const structuralValidation = validateStructure(schemaVersion, options, obj);
+
+  if (!structuralValidation.valid) {
+    return structuralValidation;
+  }
+
+  return validator.validateSyntax(options, schema);
+}
 /**
  * Validates a schema using a matching validation based on the `schemaVersion` property.
  */
 
-
-export function validateSchema(obj, options) {
+export async function validateSchema(context, obj) {
   if (isUndefined(obj)) {
-    return {
-      valid: false,
-      schema: undefined,
-      errors: [{
-        path: [],
-        type: 'undefined',
-        message: 'Schema is undefined'
-      }]
-    };
+    return schemaUndefinedResult;
   }
 
+  const contextWithDefaults = {
+    allowDisconnectedLayers: true,
+    ...context
+  };
   const schema = obj;
-  const validator = findValidator(schema.schemaVersion);
+  const schemaVersion = normalizeSchemaVersion(schema);
+  const validator = findValidator(schemaVersion);
 
   if (!validator) {
-    return {
-      valid: false,
-      schema: undefined,
-      errors: [{
-        path: [],
-        type: 'invalidVersion',
-        message: 'Unknown schema version'
-      }]
-    };
+    return invalidVersionResult;
+  }
+
+  const structuralValidation = validateStructure(schemaVersion, contextWithDefaults, obj);
+
+  if (!structuralValidation.valid) {
+    return structuralValidation;
+  }
+
+  const syntaxValidation = validator.validateSyntax(contextWithDefaults, schema);
+
+  if (!syntaxValidation.valid || !validator.validateReferences || !isValidateReferencesContext(contextWithDefaults)) {
+    return syntaxValidation;
   }
 
-  return validator(schema, options);
+  return validator.validateReferences(contextWithDefaults, obj);
 }
-export function ensureValidLatestSchema(obj) {
+export function ensureValidLatestSchemaSyntax(obj) {
   const {
     valid,
     schema,
     errors
-  } = validateSchema(obj);
+  } = validateSchemaSyntax(obj);
 
   if (!valid && errors) {
     throw new Error(`Invalid Schema "${errors[0].path.join(',')}": "${errors[0].message}"`);
@@ -1027,7 +1153,7 @@ export function ensureValidRoleImport(maybeRoles) {
  * Only use when validating an imported schema! ignore fields optional when importing
  */
 export function validateProjectSchemaImport(maybeSchema) {
-  return validateSchema(maybeSchema, {
+  return validateSchemaSyntax(maybeSchema, {
     suppressErrorPaths: [...projectSchemaImportOptionalProps, ...legacyProjectSchemaImportOptionalProps]
   });
 }