@Override public TypeName visitObject(ObjectDefinition value) { return value.getTypeName(); }
public static void validate(ObjectDefinition definition) { UNIQUE_FIELD_NAMES_VALIDATOR.validate( definition.getFields().stream() .map(FieldDefinition::getFieldName).collect(Collectors.toSet())); } }
public static TypeDefinition parseObjectType( TypeName name, com.palantir.conjure.parser.types.complex.ObjectTypeDefinition def, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { ObjectDefinition objectType = ObjectDefinition.builder() .typeName(name) .fields(parseField(def.fields(), typeResolver)) .docs(def.docs().map(Documentation::of)) .build(); ObjectDefinitionValidator.validate(objectType); return TypeDefinition.object(objectType); }
@Test public void testComplexHeaderObject() { TypeName typeName = TypeName.of("SomeObject", "com.palantir.foo"); EndpointDefinition.Builder definition = EndpointDefinition.builder() .args(ArgumentDefinition.builder() .argName(ArgumentName.of("someName")) .type(Type.reference(typeName)) .paramType(ParameterType.header(HeaderParameterType.of(ParameterId.of("SomeId")))) .build()) .endpointName(ENDPOINT_NAME) .httpMethod(HttpMethod.GET) .httpPath(HttpPath.of("/a/path")); DealiasingTypeVisitor dealiasingVisitor = new DealiasingTypeVisitor(ImmutableMap.of( typeName, TypeDefinition.object(ObjectDefinition.of(typeName, ImmutableList.of(), Documentation.of(""))) )); assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), dealiasingVisitor)) .isInstanceOf(IllegalStateException.class) .hasMessage("Header parameters must be enums, primitives, aliases or optional primitive:" + " \"someName\" is not allowed"); } }
@Test public void testNoSelfRecursiveType() { ConjureDefinition conjureDef = ConjureDefinition.builder() .version(1) .types(ImmutableList.of(TypeDefinition.object( ObjectDefinition.builder() .typeName(FOO) .fields(FieldDefinition.of(FieldName.of("self"), Type.reference(FOO), DOCS)) .build()))) .build(); assertThatThrownBy(() -> ConjureDefinitionValidator.NO_RECURSIVE_TYPES.validate(conjureDef)) .isInstanceOf(IllegalStateException.class) .hasMessage("Illegal recursive data type: Foo -> Foo"); }
@Test public void testNoRecursiveCycleType() { ConjureDefinition conjureDef = ConjureDefinition.builder() .version(1) .types(ImmutableList.of( TypeDefinition.object( ObjectDefinition.builder() .typeName(FOO) .fields(field(FieldName.of("bar"), "Bar")) .build()), TypeDefinition.object( ObjectDefinition.builder() .typeName(BAR) .fields(field(FieldName.of("foo"), "Foo")) .build()))) .build(); assertThatThrownBy(() -> ConjureDefinitionValidator.NO_RECURSIVE_TYPES.validate(conjureDef)) .isInstanceOf(IllegalStateException.class) .hasMessageStartingWith("Illegal recursive data type: "); }
@Override public TypeName visitObject(ObjectDefinition value) { return value.getTypeName(); }
private static Optional<TypeName> getReferenceType(TypeDefinition typeDef) { if (typeDef.accept(TypeDefinitionVisitor.IS_OBJECT)) { ObjectDefinition objectDef = typeDef.accept(TypeDefinitionVisitor.OBJECT); for (FieldDefinition currField : objectDef.getFields()) { Optional<TypeName> referenceType = resolveReferenceType(currField.getType()); if (referenceType.isPresent()) { return referenceType; } } } else if (typeDef.accept(TypeDefinitionVisitor.IS_ALIAS)) { AliasDefinition aliasDef = typeDef.accept(TypeDefinitionVisitor.ALIAS); return resolveReferenceType(aliasDef.getAlias()); } return Optional.empty(); }
private void testUniqueFieldNameValidator(String fieldName1, String fieldName2) { FieldDefinition field1 = FieldDefinition.builder() .fieldName(FieldName.of(fieldName1)) .type(Type.primitive(PrimitiveType.STRING)) .build(); FieldDefinition field2 = FieldDefinition.builder() .fieldName(FieldName.of(fieldName2)) .type(Type.primitive(PrimitiveType.STRING)) .build(); TypeName name = TypeName.of("Foo", "package"); ObjectDefinition definition = ObjectDefinition.builder() .typeName(name) .fields(field1) .fields(field2) .build(); assertThatThrownBy(() -> ObjectDefinitionValidator.validate(definition)) .isInstanceOf(IllegalArgumentException.class) .hasMessage(String.format("ObjectDefinition must not contain duplicate field names " + "(modulo case normalization): %s vs %s", fieldName2, fieldName1)); } }
@Test public void testRecursiveTypeOkInReference() { Type referenceType = Type.reference(FOO); TypeDefinition objectDefinition = TypeDefinition.object( ObjectDefinition.builder() .typeName(TypeName.of("Foo", "bar")) .addAllFields(ImmutableList.of( FieldDefinition.of(FieldName.of("selfOptional"), Type.optional(OptionalType.of(Type.reference(FOO))), DOCS), FieldDefinition.of(FieldName.of("selfMap"), Type.map(MapType.of(referenceType, referenceType)), DOCS), FieldDefinition.of(FieldName.of("selfSet"), Type.set(SetType.of(referenceType)), DOCS), FieldDefinition.of(FieldName.of("selfList"), Type.list(ListType.of(referenceType)), DOCS))) .build()); ConjureDefinition conjureDef = ConjureDefinition.builder() .version(1) .types(ImmutableList.of(objectDefinition)) .build(); ConjureDefinitionValidator.NO_RECURSIVE_TYPES.validate(conjureDef); }