private static void validateServiceDefinition(ServiceDefinition serviceDef, Map<TypeName, TypeDefinition> definitionMap) { serviceDef.getEndpoints().stream().forEach(endpoint -> { endpoint.getArgs().stream() .filter(arg -> recursivelyFindNestedOptionals(arg.getType(), definitionMap, false)) .findAny() .ifPresent(arg -> { throw new IllegalStateException( "Illegal nested optionals found in one of the arguments of endpoint " + endpoint.getEndpointName().get()); }); endpoint.getReturns().ifPresent(returnType -> { if (recursivelyFindNestedOptionals(returnType, definitionMap, false)) { throw new IllegalStateException( "Illegal nested optionals found in return type of endpoint " + endpoint.getEndpointName().get()); } }); }); }
@Override public void validate(ConjureDefinition definition) { // create mapping for resolving reference types during validation Map<TypeName, TypeDefinition> definitionMap = definition.getTypes().stream().collect( Collectors.toMap(entry -> entry.accept(TypeDefinitionVisitor.TYPE_NAME), entry -> entry)); definition.getTypes().stream().forEach(def -> validateTypeDefinition(def, definitionMap)); definition.getErrors().forEach(def -> validateErrorDefinition(def, definitionMap)); definition.getServices().forEach(def -> validateServiceDefinition(def, definitionMap)); }
private static boolean recursivelyFindNestedOptionals( Type type, Map<TypeName, TypeDefinition> definitionMap, boolean isOptionalSeen) { if (type.accept(TypeVisitor.IS_REFERENCE)) { TypeDefinition referenceDefinition = definitionMap.get(type.accept(TypeVisitor.REFERENCE)); // we only care about reference of alias type if (referenceDefinition != null && referenceDefinition.accept(TypeDefinitionVisitor.IS_ALIAS)) { AliasDefinition aliasDef = referenceDefinition.accept(TypeDefinitionVisitor.ALIAS); return recursivelyFindNestedOptionals(aliasDef.getAlias(), definitionMap, isOptionalSeen); } } else if (type.accept(TypeVisitor.IS_OPTIONAL)) { if (isOptionalSeen) { return true; } return recursivelyFindNestedOptionals(type.accept(TypeVisitor.OPTIONAL).getItemType(), definitionMap, true); } return false; } }
private static void validateErrorDefinition(ErrorDefinition errorDef, Map<TypeName, TypeDefinition> definitionMap) { Stream.concat(errorDef.getSafeArgs().stream(), errorDef.getUnsafeArgs().stream()) .filter(arg -> recursivelyFindNestedOptionals(arg.getType(), definitionMap, false)) .findAny() .ifPresent(arg -> { throw new IllegalStateException( "Illegal nested optionals found in one of arguments of error " + errorDef.getErrorName().getName()); }); }