@takeshape/schema 9.32.3 → 9.33.2

package/dist/validate.js

@@ -3,13 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ensureValidLatestSchema = ensureValidLatestSchema;
+exports.ensureValidLatestSchemaSyntax = ensureValidLatestSchemaSyntax;
 exports.ensureValidProjectSchemaImport = ensureValidProjectSchemaImport;
 exports.ensureValidRoleImport = ensureValidRoleImport;
 exports.formatError = formatError;
 exports.validateProjectSchemaImport = validateProjectSchemaImport;
 exports.validateRoleInput = validateRoleInput;
 exports.validateSchema = validateSchema;
+exports.validateSchemaSyntax = validateSchemaSyntax;
 
 var _types = require("./types/types");
 
@@ -79,8 +80,14 @@ var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
 
 var _pick = _interopRequireDefault(require("lodash/pick"));
 
+var _pMap = _interopRequireDefault(require("p-map"));
+
+var _lodash = require("lodash");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const builtInShapeNames = new Set([...Object.keys(_builtinSchema.builtInShapes), ..._scalars.scalars, 'object']);
+
 function findDuplicates(items) {
   const seen = {};
 
@@ -214,7 +221,24 @@ function getSemver(schemaVersion) {
   return (0, _coerce2.default)(schemaVersion) ?? _versions.LEGACY_SCHEMA_VERSION;
 }
 
-function validateResolver(projectSchema, basePath, resolver) {
+function enumerateBasicResolvers(resolver, path) {
+  const results = [];
+
+  const visit = (resolver, path) => {
+    if ((0, _utils.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
@@ -258,14 +282,14 @@ function validateResolver(projectSchema, basePath, resolver) {
   const isLessThanV3_9_0 = (0, _lt.default)(getSemver(projectSchema.schemaVersion), '3.9.0');
   const getNamespace = (0, _refs.createGetNamespace)(projectSchema);
 
-  const validateBasicResolver = resolver => {
+  for (const [resolver, path] of enumerateBasicResolvers(baseResolver, basePath)) {
     if ((0, _utils.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}"`
         });
       }
@@ -273,7 +297,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}"`
         });
       }
@@ -289,7 +313,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 ?? ''}"`
             });
           }
@@ -304,7 +328,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 ?? ''}"`
           });
         }
@@ -322,7 +346,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}"`
           });
         }
@@ -330,62 +354,115 @@ function validateResolver(projectSchema, basePath, resolver) {
     } else {
       errors.push({
         type: 'notFound',
-        path: basePath,
+        path,
         message: `Invalid resolver`
       });
     }
-  };
-
-  if ((0, _utils.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
-  } = (0, _refs.parseReturnShape)(projectSchema, query.shape);
+  return validateResolver(projectSchema, [location, name, 'resolver'], query.resolver);
+}
 
-  if (template && !(0, _templateShapes.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 (0, _pMap.default)(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 = (0, _refs.parsePropertyRef)(resolver.to);
+
+      if (ref && ref.serviceId !== 'local') {
+        const layerState = await context.resolveLayer(ref.serviceId);
+        const valid = layerState.status === 'ok' ? Boolean((0, _get.default)(layerState.schema, (0, _refs.propertyRefItemToPath)((0, _util.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);
+}
 
-  for (const name of Object.keys(projectSchema.queries)) {
-    errors = errors.concat(validateQueryConfig(projectSchema, validReturnShapes, projectSchema.queries[name], 'query', name));
+async function validateQueryConfigs(context, projectSchema) {
+  const isLessThanV3_9_0 = (0, _lt.default)(getSemver(projectSchema.schemaVersion), '3.9.0');
+
+  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 (0, _lodash.flatten)(await Promise.all(promises));
 }
 
 function validateIndexedShapeConfig(projectSchema, shapeName, config) {
@@ -467,8 +544,6 @@ function validateIndexedShapes(projectSchema) {
   return errors;
 }
 
-const builtInShapeNames = [...Object.keys(_builtinSchema.builtInShapes), ..._scalars.scalars, 'object'];
-
 function getModelShapeIds(shapes) {
   return Object.values(shapes).filter(shape => shape.model).map(shape => shape.id);
 }
@@ -483,44 +558,94 @@ function isAllOfPath(path) {
   return index !== -1 && (0, _util.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 = (0, _schemaUtil.getAllRefsInShapes)(projectSchema);
+  const shapeNames = new Set([...builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
+  const refs = (0, _schemaUtil.getAllRefs)(projectSchema).filter(item => !item.isForeign);
 
-  if (refs.length > 0) {
-    refs.forEach(item => {
-      const shapeName = (0, _refs.refItemToShapeName)(item);
+  for (const item of refs) {
+    if (item.template && !(0, _templateShapes.isValidTemplate)(item.template)) {
+      errors.push({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid template "${item.template}"`
+      });
+    }
 
-      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
+    const shapeName = (0, _refs.refItemToShapeName)(item);
 
+    if (!shapeNames.has(shapeName)) {
+      errors.push({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid ref "${(0, _get.default)(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`
-        });
-      }
 
-      const parentPath = (0, _initial.default)(item.path);
-      const parentSchema = (0, _get.default)(projectSchema, parentPath);
-      const propName = (0, _last.default)(item.path);
+    if (item.path[1] === shapeName && isAllOfPath(item.path)) {
+      errors.push({
+        type: 'conflict',
+        path: item.path,
+        message: `allOf cannot be self-referential`
+      });
+    }
 
-      if (propName === '@ref' && parentSchema.$ref) {
-        errors.push({
-          type: 'conflict',
-          path: parentPath,
-          message: `Ref cannot have both @ref and $ref`
-        });
-      }
-    });
+    const parentPath = (0, _initial.default)(item.path);
+    const parentSchema = (0, _get.default)(projectSchema, parentPath);
+    const propName = (0, _last.default)(item.path);
+
+    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 = (0, _schemaUtil.getAllRefs)(projectSchema);
+  const layerIds = new Set();
+
+  for (const item of refs) {
+    if (item.serviceKey !== 'local') {
+      layerIds.add(item.serviceKey);
+    }
+  }
+
+  const layersById = Object.fromEntries(await (0, _pMap.default)(layerIds, async layerId => [layerId, await resolveLayer(layerId)]));
+
+  for (const item of refs) {
+    if (item.template && !(0, _templateShapes.isValidTemplate)(item.template)) {
+      errors.push({
+        type: 'notFound',
+        path: item.path,
+        message: `Invalid template "${item.path}"`
+      });
+    }
+
+    const {
+      serviceKey: layerId
+    } = item;
+    const shapeName = (0, _refs.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 "${(0, _get.default)(projectSchema, item.path)}"`
+      });
+    }
   }
 
   return errors;
@@ -788,9 +913,13 @@ function formatError(error) {
   };
 }
 
+function isValidateReferencesContext(context) {
+  return Boolean(context.resolveLayer);
+}
+
 const ajv = (0, _jsonSchema.createAjv)();
 
-function validateStructure(schemaVersion, schema, ref, options) {
+function validateStructure(schemaVersion, context, schema, ref) {
   var _coerce, _ajv$errors;
 
   const versionStr = (_coerce = (0, _coerce2.default)(schemaVersion)) === null || _coerce === void 0 ? void 0 : _coerce.format();
@@ -805,7 +934,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 => {
@@ -828,20 +959,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 = (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)).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 => {
@@ -860,133 +981,142 @@ 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 = (0, _lodash.flatten)(await Promise.all([validateRefs(context, schema), validateQueryConfigs(context, schema)]));
+    return formatValidationResult(context, errors, schema);
+  }
+
 }];
 
 function findValidator(schemaVersion) {
-  const normalizedSchemaVersion = schemaVersion ?? '1';
-  const schemaSemVer = (0, _coerce2.default)(normalizedSchemaVersion);
+  const schemaSemVer = (0, _coerce2.default)(schemaVersion);
 
   if (schemaSemVer) {
     const validator = validators.find(v => (0, _satisfies.default)(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';
+}
+
+function validateSchemaSyntax(obj, options = {}) {
+  if ((0, _isUndefined.default)(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.
  */
 
 
-function validateSchema(obj, options) {
+async function validateSchema(context, obj) {
   if ((0, _isUndefined.default)(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);
 }
 
-function ensureValidLatestSchema(obj) {
+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}"`);
@@ -1080,7 +1210,7 @@ function ensureValidRoleImport(maybeRoles) {
  * Only use when validating an imported schema! ignore fields optional when importing
  */
 function validateProjectSchemaImport(maybeSchema) {
-  return validateSchema(maybeSchema, {
+  return validateSchemaSyntax(maybeSchema, {
     suppressErrorPaths: [..._types.projectSchemaImportOptionalProps, ..._types.legacyProjectSchemaImportOptionalProps]
   });
 }

package/es/schema-util.js

@@ -746,7 +746,7 @@ export function getAllRefsInQuery(projectSchema, queryPath, query, predicate) {
   }
 
   if (query.args && typeof query.args === 'object') {
-    visitSchemaProperties(dereferenceObjectSchema(projectSchema, query.args), queryPath, propertyVisitor);
+    visitSchemaProperties(dereferenceObjectSchema(projectSchema, query.args), [...queryPath, 'args'], propertyVisitor);
   }
 
   if (query.shape) {