Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -3,13 +3,29 @@
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
* Simple transformer than injects schema definitions into the `#/components/schemas` path so that references resolve correctly.
* <p>
* Only the definitions the schema can reach are injected: the ones it refers to, and the ones those refer to in turn.
* A compiled schema is cached, so every definition injected here is retained for as long as the cache entry lives.
* Injecting all of them made the retained size grow with (number of schemas validated) x (size of the specification),
* even when the specification was loaded fully resolved and the schema referred to none of them.
*/
public class SchemaDefinitionsInjectionTransformer extends SchemaTransformer {

private static final SchemaDefinitionsInjectionTransformer INSTANCE = new SchemaDefinitionsInjectionTransformer();

private static final String SCHEMA_REF_PREFIX = "#/components/schemas/";
private static final String MAPPING_FIELD = "mapping";

public static SchemaDefinitionsInjectionTransformer getInstance() {
return INSTANCE;
}
Expand All @@ -20,6 +36,71 @@ public void apply(final JsonNode schemaObject, final SchemaTransformationContext
return;
}

((ObjectNode) schemaObject).putObject(COMPONENTS_FIELD).set(SCHEMAS_FIELD, context.getSchemaDefinitions().deepCopy());
final JsonNode definitions = context.getSchemaDefinitions();
final ObjectNode injected = ((ObjectNode) schemaObject).putObject(COMPONENTS_FIELD).putObject(SCHEMAS_FIELD);
if (definitions == null) {
return;
}
final Set<String> referenced = referencedDefinitions(schemaObject, definitions);
// In the order they are declared, so the injected block does not depend on traversal order.
for (final Map.Entry<String, JsonNode> definition : definitions.properties()) {
if (referenced.contains(definition.getKey())) {
injected.set(definition.getKey(), definition.getValue().deepCopy());
}
}
}

/**
* The names of the definitions reachable from the given schema, directly or through other definitions.
* <p>
* Any text value that points at a definition counts, not only the value of a {@code $ref}, and so does a
* discriminator mapping that names a definition without the path.
*/
private static Set<String> referencedDefinitions(final JsonNode schemaObject, final JsonNode definitions) {
final Set<String> referenced = new HashSet<>();
final Deque<JsonNode> pending = new ArrayDeque<>();
pending.push(schemaObject);
while (!pending.isEmpty()) {
final JsonNode node = pending.pop();
if (node.isObject()) {
for (final Map.Entry<String, JsonNode> field : node.properties()) {
if (MAPPING_FIELD.equals(field.getKey()) && field.getValue().isObject()) {
field.getValue().forEach(target -> reference(target.asText(), definitions, referenced, pending));
}
pending.push(field.getValue());
}
} else if (node.isArray()) {
node.forEach(pending::push);
} else if (node.isTextual() && node.textValue().startsWith(SCHEMA_REF_PREFIX)) {
reference(definitionName(node.textValue()), definitions, referenced, pending);
}
}
return referenced;
}

// A reference can point inside a definition, e.g. #/components/schemas/Order/properties/customer
private static String definitionName(final String reference) {
final int end = reference.indexOf('/', SCHEMA_REF_PREFIX.length());
return end < 0 ? reference.substring(SCHEMA_REF_PREFIX.length()) : reference.substring(SCHEMA_REF_PREFIX.length(), end);
}

private static void reference(final String name,
final JsonNode definitions,
final Set<String> referenced,
final Deque<JsonNode> pending) {
final String key = definitions.has(name) ? name : decoded(name);
final JsonNode definition = definitions.get(key);
if (definition != null && referenced.add(key)) {
pending.push(definition);
}
}

// A reference is a URI fragment holding a JSON Pointer, so it can percent-encode the name and escape '~' and '/' in it.
private static String decoded(final String name) {
try {
return URLDecoder.decode(name.replace("+", "%2B"), StandardCharsets.UTF_8).replace("~1", "/").replace("~0", "~");
} catch (final IllegalArgumentException e) {
return name;
}
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,117 @@
package com.atlassian.oai.validator.schema.transform;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class SchemaDefinitionsInjectionTransformerTest {

private static final ObjectMapper MAPPER = new ObjectMapper();

private static final String DEFINITIONS = "{"
+ "\"Order\":{\"type\":\"object\",\"properties\":{\"customer\":{\"$ref\":\"#/components/schemas/Customer\"}}},"
+ "\"Customer\":{\"type\":\"object\",\"properties\":{\"address\":{\"$ref\":\"#/components/schemas/Address\"}}},"
+ "\"Address\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}}},"
+ "\"Folder\":{\"type\":\"object\",\"properties\":{\"children\":{\"type\":\"array\","
+ "\"items\":{\"$ref\":\"#/components/schemas/Folder\"}}}},"
+ "\"Cat\":{\"type\":\"object\"},"
+ "\"Dog\":{\"type\":\"object\"},"
+ "\"Line Item\":{\"type\":\"object\"},"
+ "\"Tax/Rate\":{\"type\":\"object\"},"
+ "\"Unrelated\":{\"type\":\"object\"}"
+ "}";

private final SchemaDefinitionsInjectionTransformer classUnderTest = SchemaDefinitionsInjectionTransformer.getInstance();

@Test
public void injectsNothing_whenSchemaRefersToNoDefinition() throws Exception {
final ObjectNode schema = schema("{\"type\":\"object\",\"properties\":{\"name\":{\"type\":\"string\"}}}");

classUnderTest.apply(schema, context());

assertEquals(List.of(), injected(schema));
}

@Test
public void injectsReferencedDefinitions_andTheOnesTheyReferTo() throws Exception {
final ObjectNode schema = schema("{\"type\":\"array\",\"items\":{\"$ref\":\"#/components/schemas/Order\"}}");

classUnderTest.apply(schema, context());

assertEquals(List.of("Order", "Customer", "Address"), injected(schema));
}

@Test
public void injectsSelfReferencingDefinition_once() throws Exception {
final ObjectNode schema = schema("{\"$ref\":\"#/components/schemas/Folder\"}");

classUnderTest.apply(schema, context());

assertEquals(List.of("Folder"), injected(schema));
}

@Test
public void injectsDefinition_whenReferenceGoesIntoIt() throws Exception {
final ObjectNode schema = schema("{\"$ref\":\"#/components/schemas/Order/properties/customer\"}");

classUnderTest.apply(schema, context());

assertEquals(List.of("Order", "Customer", "Address"), injected(schema));
}

@Test
public void injectsDefinition_whenReferenceEncodesItsName() throws Exception {
final ObjectNode schema = schema("{\"type\":\"object\",\"properties\":{"
+ "\"item\":{\"$ref\":\"#/components/schemas/Line%20Item\"},"
+ "\"rate\":{\"$ref\":\"#/components/schemas/Tax~1Rate\"}}}");

classUnderTest.apply(schema, context());

assertEquals(List.of("Line Item", "Tax/Rate"), injected(schema));
}

@Test
public void injectsDefinitionsNamedByDiscriminatorMapping_withAndWithoutPath() throws Exception {
final ObjectNode schema = schema("{\"oneOf\":[{\"type\":\"object\"},{\"type\":\"object\"}],"
+ "\"discriminator\":{\"propertyName\":\"kind\","
+ "\"mapping\":{\"cat\":\"#/components/schemas/Cat\",\"dog\":\"Dog\"}}}");

classUnderTest.apply(schema, context());

assertEquals(List.of("Cat", "Dog"), injected(schema));
}

@Test
public void injectsCopies_soTheSharedDefinitionsAreNeverMutated() throws Exception {
final SchemaTransformationContext context = context();
final ObjectNode schema = schema("{\"$ref\":\"#/components/schemas/Address\"}");

classUnderTest.apply(schema, context);
((ObjectNode) schema.at("/components/schemas/Address")).put("additionalProperties", false);

assertTrue(schema.at("/components/schemas/Address").has("additionalProperties"));
assertFalse(context.getSchemaDefinitions().get("Address").has("additionalProperties"));
}

private static List<String> injected(final JsonNode schema) {
final List<String> names = new ArrayList<>();
schema.at("/components/schemas").fieldNames().forEachRemaining(names::add);
return names;
}

private static ObjectNode schema(final String json) throws Exception {
return (ObjectNode) MAPPER.readTree(json);
}

private static SchemaTransformationContext context() throws Exception {
return SchemaTransformationContext.create().withDefinitions(MAPPER.readTree(DEFINITIONS)).build();
}
}