@Override public void validate(EndpointDefinition definition) { List<ArgumentDefinition> bodyParams = definition.getArgs() .stream() .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_BODY)) .collect(Collectors.toList()); Preconditions.checkState(bodyParams.size() <= 1, "Endpoint cannot have multiple body parameters: %s", bodyParams.stream().map(e -> e.getArgName()).collect(Collectors.toList())); } }
@Override public void validate(EndpointDefinition definition) { definition.getArgs().forEach(arg -> { Matcher matcher = ANCHORED_PATTERN.matcher(arg.getArgName().get()); Preconditions.checkState(matcher.matches(), "Parameter names in endpoint paths and service definitions must match pattern %s: %s", ANCHORED_PATTERN, arg.getArgName().get()); }); } }
@Override public void validate(EndpointDefinition definition, DealiasingTypeVisitor dealiasingTypeVisitor) { definition.getArgs().stream() .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_QUERY)) .forEach(argDefinition -> { boolean isValid = recursivelyValidate(argDefinition.getType(), dealiasingTypeVisitor); Preconditions.checkState(isValid, "Query parameters must be enums, primitives, aliases, list, sets " + "or optional of primitive: \"%s\" is not allowed", argDefinition.getArgName()); }); }
@Override public void validate(EndpointDefinition definition, DealiasingTypeVisitor dealiasingTypeVisitor) { definition.getArgs().stream() .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_HEADER)) .forEach(headerArgDefinition -> { boolean isValid = recursivelyValidate(headerArgDefinition.getType(), dealiasingTypeVisitor); Preconditions.checkState(isValid, "Header parameters must be enums, primitives, aliases or optional primitive:" + " \"%s\" is not allowed", headerArgDefinition.getArgName()); }); }
@Override public void validate(EndpointDefinition definition) { Set<ArgumentName> pathParamIds = new HashSet<>(); definition.getArgs().stream() .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_PATH)) .forEach(entry -> { boolean added = pathParamIds.add(entry.getArgName()); Preconditions.checkState(added, "Path parameter with identifier \"%s\" is defined multiple times for endpoint", entry.getArgName().get()); }); Set<ArgumentName> pathArgs = HttpPathValidator.pathArgs(definition.getHttpPath().get()); Set<ArgumentName> extraParams = Sets.difference(pathParamIds, pathArgs); Preconditions.checkState(extraParams.isEmpty(), "Path parameters defined in endpoint but not present in path template: %s. " + "Note that the `param-id` is no longer supported and the path template name is always " + "used instead. So make sure the path template name matches the path parameter defined " + "in endpoint.", extraParams); Set<ArgumentName> missingParams = Sets.difference(pathArgs, pathParamIds); Preconditions.checkState(missingParams.isEmpty(), "Path parameters defined path template but not present in endpoint: %s", missingParams); } }
@Override public void validate(EndpointDefinition definition) { HttpMethod method = definition.getHttpMethod(); if (method.equals(HttpMethod.GET)) { boolean hasBody = definition.getArgs() .stream() .anyMatch(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_BODY)); Preconditions.checkState(!hasBody, "Endpoint cannot be a GET and contain a body: method: %s, path: %s", definition.getHttpMethod(), definition.getHttpPath()); } } }
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(EndpointDefinition definition, DealiasingTypeVisitor dealiasingTypeVisitor) { definition.getArgs().stream() .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_PATH)) .forEach(entry -> { Either<TypeDefinition, Type> resolvedType = dealiasingTypeVisitor.dealias(entry.getType()); Boolean isValid = resolvedType.fold( typeDefinition -> typeDefinition.accept(TypeDefinitionVisitor.IS_ENUM), type -> type.accept(TypeVisitor.IS_PRIMITIVE)); Preconditions.checkState(isValid, "Path parameters must be primitives or aliases: \"%s\" is not allowed", entry.getArgName()); }); } }
@Override public void validate(EndpointDefinition definition, DealiasingTypeVisitor dealiasingTypeVisitor) { definition.getArgs() .stream() .filter(arg -> !arg.getParamType().accept(ParameterTypeVisitor.IS_BODY)) .forEach(arg -> { boolean isValid = dealiasingTypeVisitor.dealias(arg.getType()) .fold( typeDefinition -> true, type -> !type.accept(TypeVisitor.IS_BINARY) && !type.accept(TypeVisitor.IS_ANY) ); Preconditions.checkArgument( isValid, "Non body parameters cannot be of the 'binary' type: '%s' is not allowed", arg.getArgName()); }); } }
@Override public void validate(EndpointDefinition definition, DealiasingTypeVisitor dealiasingTypeVisitor) { definition.getArgs().stream() .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_PATH) || entry.getParamType().accept(ParameterTypeVisitor.IS_QUERY)) .forEach(entry -> { Either<TypeDefinition, Type> conjureType = dealiasingTypeVisitor.dealias(entry.getType()); boolean isValid = conjureType.fold( typeDefinition -> true, type -> !type.accept(TypeVisitor.IS_PRIMITIVE) || type.accept(TypeVisitor.PRIMITIVE).get() != PrimitiveType.Value.BEARERTOKEN ); Preconditions.checkState(isValid, "Path or query parameters of type 'bearertoken' are not allowed as this " + "would introduce a security vulnerability: \"%s\"", entry.getArgName()); }); } }
@Override public void validate(EndpointDefinition definition) { definition.getArgs().forEach(arg -> { final Pattern pattern; ParameterType paramType = arg.getParamType(); if (paramType.accept(ParameterTypeVisitor.IS_BODY) || paramType.accept(ParameterTypeVisitor.IS_PATH) || paramType.accept(ParameterTypeVisitor.IS_QUERY)) { pattern = ANCHORED_PATTERN; } else if (paramType.accept(ParameterTypeVisitor.IS_HEADER)) { pattern = HEADER_PATTERN; } else { throw new IllegalStateException("Validation for paramType does not exist: " + arg.getParamType()); } if (paramType.accept(ParameterTypeVisitor.IS_QUERY)) { ParameterId paramId = paramType.accept(ParameterTypeVisitor.QUERY).getParamId(); Preconditions.checkState(pattern.matcher(paramId.get()).matches(), "Parameter ids with type %s must match pattern %s: %s", arg.getParamType(), pattern, paramId.get()); } else if (paramType.accept(ParameterTypeVisitor.IS_HEADER)) { ParameterId paramId = paramType.accept(ParameterTypeVisitor.HEADER).getParamId(); Preconditions.checkState(pattern.matcher(paramId.get()).matches(), "Parameter ids with type %s must match pattern %s: %s", arg.getParamType(), pattern, paramId.get()); } }); } }