Refactor SchemaRegistry

Author: justin-tay

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

@@ -40,7 +40,7 @@
 
 /**
  * Used for creating a schema with validators for validating inputs. This is
- * created using {@link SchemaRegistry#getInstance(Version, Consumer)}
+ * created using {@link SchemaRegistry#withDefaultDialect(Version, Consumer)}
  * and should be cached for performance.
  * <p>
  * This is the core of json constraint implementation. It parses json constraint

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

@@ -17,7 +17,9 @@
 
 import java.util.Optional;
 
+import com.networknt.schema.dialect.Dialect;
 import com.networknt.schema.dialect.DialectId;
+import com.networknt.schema.dialect.Dialects;
 
 /**
  * The JSON Schema specification which defines the standard dialects.
@@ -95,4 +97,56 @@ public static Optional<Version> fromDialectId(String dialectId) {
             return Optional.empty();
         }
     }
+
+    /**
+     * Gets the dialect given the specification version.
+     * 
+     * @param version the schema specification version
+     * @return the dialect or null if not found
+     */
+    public static Dialect getDialect(Specification.Version version) {
+        if (null == version) {
+            return null;
+        }
+        switch (version) {
+        case DRAFT_2020_12:
+            return Dialects.getDraft202012();
+        case DRAFT_2019_09:
+            return Dialects.getDraft201909();
+        case DRAFT_7:
+            return Dialects.getDraft7();
+        case DRAFT_6:
+            return Dialects.getDraft6();
+        case DRAFT_4:
+            return Dialects.getDraft4();
+        default:
+            return null;
+        }
+    }
+
+    /**
+     * Gets the dialect given the dialect id.
+     * 
+     * @param version the schema specification version
+     * @return the dialect or null if not found
+     */
+    public static Dialect getDialect(String dialectId) {
+        if (null == dialectId) {
+            return null;
+        }
+        switch (dialectId) {
+        case DialectId.DRAFT_2020_12:
+            return Dialects.getDraft202012();
+        case DialectId.DRAFT_2019_09:
+            return Dialects.getDraft201909();
+        case DialectId.DRAFT_7:
+            return Dialects.getDraft7();
+        case DialectId.DRAFT_6:
+            return Dialects.getDraft6();
+        case DialectId.DRAFT_4:
+            return Dialects.getDraft4();
+        default:
+            return null;
+        }
+    }
 }

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

@@ -75,7 +75,7 @@ public static Optional<Version> detectOptionalVersion(JsonNode jsonNode, boolean
         return Optional.ofNullable(jsonNode.get(SCHEMA_TAG)).map(schemaTag -> {
 
             String schemaTagValue = schemaTag.asText();
-            String schemaUri = SchemaRegistry.normalizeMetaSchemaUri(schemaTagValue);
+            String schemaUri = SchemaRegistry.normalizeDialectId(schemaTagValue);
 
             if (throwIfUnsupported) {
                 return Version.fromDialectId(schemaUri)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 the original author or authors.
+ * Copyright (c) 2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,33 +15,32 @@
  */
 package com.networknt.schema.dialect;
 
+import java.util.function.Function;
+
 import com.networknt.schema.Error;
 import com.networknt.schema.InvalidSchemaException;
 import com.networknt.schema.SchemaRegistry;
 import com.networknt.schema.SchemaValidatorsConfig;
 
-/**
- * A {@link DialectRegistry} that does not meta-schemas that aren't
- * explicitly configured in the {@link SchemaRegistry}.
- */
-public class DisallowUnknownDialectFactory implements DialectRegistry {
-    @Override
-    public Dialect getDialect(String dialectId, SchemaRegistry schemaFactory, SchemaValidatorsConfig config) {
-        throw new InvalidSchemaException(Error.builder()
-                .message("Unknown dialect ''{0}''. Only dialects that are explicitly configured can be used.")
-                .arguments(dialectId).build());
+public class BasicDialectRegistry implements DialectRegistry {
+    private Function<String, Dialect> dialects;
+
+    public BasicDialectRegistry(Function<String, Dialect> dialects) {
+        this.dialects = dialects;
     }
 
-    private static class Holder {
-        private static final DisallowUnknownDialectFactory INSTANCE = new DisallowUnknownDialectFactory();
+    public BasicDialectRegistry(Dialect dialect) {
+        this.dialects = dialectId -> dialect.getIri().equals(dialectId) ? dialect : null;
     }
 
-    /**
-     * Gets the instance of {@link DisallowUnknownDialectFactory}.
-     * 
-     * @return the json meta schema factory
-     */
-    public static DisallowUnknownDialectFactory getInstance() {
-        return Holder.INSTANCE;
+    @Override
+    public Dialect getDialect(String dialectId, SchemaRegistry schemaRegistry, SchemaValidatorsConfig config) {
+        Dialect dialect = dialects.apply(dialectId);
+        if (dialect != null) {
+            return dialect;
+        }
+        throw new InvalidSchemaException(Error.builder()
+                .message("Unknown dialect ''{0}''. Only dialects that are explicitly configured can be used.")
+                .arguments(dialectId).build());
     }
 }

src/main/java/com/networknt/schema/dialect/DisallowUnknownDialectFactory.java renamed to src/main/java/com/networknt/schema/dialect/BasicDialectRegistry.java

@@ -17,6 +17,8 @@
 
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.networknt.schema.Error;
@@ -32,13 +34,16 @@
  * Default {@link DialectRegistry}.
  */
 public class DefaultDialectRegistry implements DialectRegistry {
+    private final ConcurrentMap<String, Dialect> dialects = new ConcurrentHashMap<>();
+    
     @Override
     public Dialect getDialect(String dialectId, SchemaRegistry schemaFactory, SchemaValidatorsConfig config) {
         // Is it a well-known dialect?
-        return Specification.Version.fromDialectId(dialectId).map(SchemaRegistry::checkVersion).orElseGet(() -> {
-            // Custom dialect
-            return loadDialect(dialectId, schemaFactory, config);
-        });
+        Dialect dialect = Specification.getDialect(dialectId);
+        if (dialect != null) {
+            return dialect;
+        }
+        return dialects.computeIfAbsent(dialectId, id -> loadDialect(id, schemaFactory, config));
     }
 
     protected Dialect loadDialect(String iri, SchemaRegistry schemaFactory, SchemaValidatorsConfig config) {

src/main/java/com/networknt/schema/dialect/DefaultDialectRegistry.java

@@ -29,12 +29,13 @@ public interface DialectRegistry {
      * Gets the dialect given the dialect id which is the IRI that indicates the
      * meta-schema that can be used to validate the schema conforms to the dialect.
      * 
-     * @param dialectId     the dialect id of the dialect which IRI that indicates
-     *                      the meta-schema that can be used to validate the schema
-     *                      conforms to the dialect
-     * @param schemaFactory the schema factory
-     * @param config        the config
+     * @param dialectId      the dialect id of the dialect which IRI that indicates
+     *                       the meta-schema that can be used to validate the schema
+     *                       conforms to the dialect
+     * @param schemaRegistry the schema registry to fetch and load unknown dialect's
+     *                       meta-schema
+     * @param config         the config
      * @return the dialect
      */
-    Dialect getDialect(String dialectId, SchemaRegistry schemaFactory, SchemaValidatorsConfig config);
+    Dialect getDialect(String dialectId, SchemaRegistry schemaRegistry, SchemaValidatorsConfig config);
 }

src/main/java/com/networknt/schema/dialect/DialectRegistry.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.networknt.schema.serialization;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.InputFormat;
+
+/**
+ * BasicJsonNodeReader.
+ */
+public class BasicJsonNodeReader implements JsonNodeReader {
+    private static class Holder {
+        private static final BasicJsonNodeReader INSTANCE = new BasicJsonNodeReader();
+    }
+
+    public static BasicJsonNodeReader getInstance() {
+        return Holder.INSTANCE;
+    }
+
+    protected BasicJsonNodeReader() {
+    }
+
+    @Override
+    public JsonNode readTree(String content, InputFormat inputFormat) throws IOException {
+        return getObjectMapper(inputFormat).readTree(content);
+    }
+
+    @Override
+    public JsonNode readTree(InputStream content, InputFormat inputFormat) throws IOException {
+        return getObjectMapper(inputFormat).readTree(content);
+    }
+
+    /**
+     * Gets the object mapper for the input format.
+     * 
+     * @param inputFormat the input format
+     * @return the object mapper
+     */
+    protected ObjectMapper getObjectMapper(InputFormat inputFormat) {
+        if (InputFormat.JSON.equals(inputFormat)) {
+            return JsonMapperFactory.getInstance();
+        } else if (InputFormat.YAML.equals(inputFormat)) {
+            return YamlMapperFactory.getInstance();
+        }
+        throw new IllegalArgumentException("Unsupported input format "+inputFormat); 
+    }
+}

src/main/java/com/networknt/schema/serialization/BasicJsonNodeReader.java

@@ -60,7 +60,7 @@ private JsonNode getJsonNodeFromPath(String dataPath) {
 
     private Schema getJsonSchema(JsonNode schemaNode) {
         return SchemaRegistry
-                .getInstance(SpecificationVersionDetector.detectOptionalVersion(schemaNode, false).orElse(DEFAULT_VERSION_FLAG))
+                .withDefaultDialect(SpecificationVersionDetector.detectOptionalVersion(schemaNode, false).orElse(DEFAULT_VERSION_FLAG))
                 .getSchema(schemaNode);
     }
 

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

@@ -202,7 +202,7 @@ public InputStreamSource getSchema(AbsoluteIri absoluteIri) {
             }
         };
         Version specVersion = detectVersion(testCase.getSchema(), testCase.getSpecification(), defaultVersion, false);
-        SchemaRegistry base = SchemaRegistry.getInstance(specVersion);
+        SchemaRegistry base = SchemaRegistry.withDefaultDialect(specVersion);
         return SchemaRegistry
                 .builder(base)
                 .schemaMappers(schemaMappers -> schemaMappers