Add option to disable uri schema cache in JsonSchemaFactory (#679)

* Add config to opt out of json schema cache

* cacheSchema to enableUriSchemaCache

Author: Kaaviyan

src/main/java/com/networknt/schema/JsonSchemaFactory.java

@@ -51,6 +51,7 @@ public static class Builder {
         private final Map<String, String> uriMap = new HashMap<String, String>();
         private boolean forceHttps = true;
         private boolean removeEmptyFragmentSuffix = true;
+        private boolean enableUriSchemaCache = true;
 
         public Builder() {
             // Adds support for creating {@link URL}s.
@@ -157,6 +158,11 @@ public Builder removeEmptyFragmentSuffix(boolean removeEmptyFragmentSuffix) {
             return this;
         }
 
+        public Builder enableUriSchemaCache(boolean enableUriSchemaCache) {
+            this.enableUriSchemaCache = enableUriSchemaCache;
+            return this;
+        }
+
         public JsonSchemaFactory build() {
             // create builtin keywords with (custom) formats.
             return new JsonSchemaFactory(
@@ -169,7 +175,8 @@ public JsonSchemaFactory build() {
                     jsonMetaSchemas,
                     uriMap,
                     forceHttps,
-                    removeEmptyFragmentSuffix
+                    removeEmptyFragmentSuffix,
+                    enableUriSchemaCache
             );
         }
     }
@@ -185,6 +192,7 @@ public JsonSchemaFactory build() {
     private final ConcurrentMap<URI, JsonSchema> uriSchemaCache = new ConcurrentHashMap<URI, JsonSchema>();
     private final boolean forceHttps;
     private final boolean removeEmptyFragmentSuffix;
+    private final boolean enableUriSchemaCache;
 
 
     private JsonSchemaFactory(
@@ -197,7 +205,8 @@ private JsonSchemaFactory(
             final Map<String, JsonMetaSchema> jsonMetaSchemas,
             final Map<String, String> uriMap,
             final boolean forceHttps,
-            final boolean removeEmptyFragmentSuffix) {
+            final boolean removeEmptyFragmentSuffix,
+            final boolean enableUriSchemaCache) {
         if (jsonMapper == null) {
             throw new IllegalArgumentException("ObjectMapper must not be null");
         } else if (yamlMapper == null) {
@@ -225,6 +234,7 @@ private JsonSchemaFactory(
         this.uriMap = uriMap;
         this.forceHttps = forceHttps;
         this.removeEmptyFragmentSuffix = removeEmptyFragmentSuffix;
+        this.enableUriSchemaCache = enableUriSchemaCache;
     }
 
     /**
@@ -373,7 +383,7 @@ public JsonSchema getSchema(final URI schemaUri, final SchemaValidatorsConfig co
                 throw new JsonSchemaException(e);
             }
 
-            if (uriSchemaCache.containsKey(mappedUri)) {
+            if (enableUriSchemaCache && uriSchemaCache.containsKey(mappedUri)) {
                 JsonSchema cachedUriSchema =  uriSchemaCache.get(mappedUri);
                 // This is important because if we use same JsonSchemaFactory for creating multiple JSONSchema instances,
                 // these schemas will be cached along with config. We have to replace the config for cached $ref references
@@ -404,7 +414,10 @@ public JsonSchema getSchema(final URI schemaUri, final SchemaValidatorsConfig co
                     validationContext.setConfig(config);
                     jsonSchema = new JsonSchema(validationContext, mappedUri, schemaNode);
                 }
-                uriSchemaCache.put(mappedUri, jsonSchema);
+
+                if (enableUriSchemaCache) {
+                    uriSchemaCache.put(mappedUri, jsonSchema);
+                }
 
                 return jsonSchema;
             } finally {

src/test/java/com/networknt/schema/JsonSchemaFactoryUriCacheTest.java

@@ -0,0 +1,75 @@
+package com.networknt.schema;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.uri.ClasspathURLFactory;
+import com.networknt.schema.uri.URIFetcher;
+import com.networknt.schema.uri.URLFactory;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class JsonSchemaFactoryUriCacheTest {
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    private final ClasspathURLFactory classpathURLFactory = new ClasspathURLFactory();
+
+    @Test
+    public void cacheEnabled() throws JsonProcessingException {
+        runCacheTest(true);
+    }
+
+    @Test
+    public void cacheDisabled() throws JsonProcessingException {
+        runCacheTest(false);
+    }
+
+    private void runCacheTest(boolean enableCache) throws JsonProcessingException {
+        CustomURIFetcher fetcher = new CustomURIFetcher();
+        JsonSchemaFactory factory = buildJsonSchemaFactory(fetcher, enableCache);
+        URI schemaUri = classpathURLFactory.create("cache:uri_mapping/schema1.json");
+        String schema = "{ \"$schema\": \"https://json-schema.org/draft/2020-12/schema#\", \"title\": \"json-object-with-schema\", \"type\": \"string\" }";
+        fetcher.addResource(schemaUri, schema);
+        assertEquals(objectMapper.readTree(schema), factory.getSchema(schemaUri, new SchemaValidatorsConfig()).schemaNode);
+
+        String modifiedSchema = "{ \"$schema\": \"https://json-schema.org/draft/2020-12/schema#\", \"title\": \"json-object-with-schema\", \"type\": \"object\" }";
+        fetcher.addResource(schemaUri, modifiedSchema);
+
+        assertEquals(objectMapper.readTree(enableCache ? schema : modifiedSchema), factory.getSchema(schemaUri, new SchemaValidatorsConfig()).schemaNode);
+    }
+
+    private JsonSchemaFactory buildJsonSchemaFactory(CustomURIFetcher uriFetcher, boolean enableUriSchemaCache) {
+        return JsonSchemaFactory.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V202012))
+                .enableUriSchemaCache(enableUriSchemaCache)
+                .uriFetcher(uriFetcher, "cache")
+                .uriFactory(new URLFactory(), "cache")
+                .addMetaSchema(JsonMetaSchema.getV202012())
+                .build();
+    }
+
+    private class CustomURIFetcher implements URIFetcher {
+
+        private Map<URI, InputStream> uriToResource = new HashMap<>();
+
+        void addResource(URI uri, String schema) {
+            addResource(uri, new ByteArrayInputStream(schema.getBytes(StandardCharsets.UTF_8)));
+        }
+
+        void addResource(URI uri, InputStream is) {
+            uriToResource.put(uri, is);
+        }
+
+        @Override
+        public InputStream fetch(URI uri) throws IOException {
+            return uriToResource.get(uri);
+        }
+    }
+}