Merge pull request #9 from jurgiskg/default-classpath-resolution-scope

Allow relative file resolution in $ref fields

Author: luposlip

src/json_schema/core.clj

@@ -25,25 +25,42 @@
         (JSONObject. ^JSONTokener json-tokener)))
     (throw (ex-info "Unsupported JSON input" {:input input}))))
 
-(defn- is-schema-input-valid? [input]
-  (or (map? input)
-      (and (string? input)
-           (= \{ (first input)))))
+(defn- assert-schema-input-valid! [input]
+  (let [is-input-valid? (or (map? input)
+                      (and (string? input)
+                           (= \{ (first input))))]
+    (when-not is-input-valid?
+      (throw (ex-info "Unsupported Schema input" {:input input})))))
 
 (defn ^JSONObject prepare-schema*
-  "Prepares JSON Schema based on input string or map.
-  You can pass optional parameter :classpath-aware, in case you want to
-  refer to relative file schemas via classpath in $ref fields."
-  [input & params]
-  (when-not (is-schema-input-valid? input)
-    (throw (ex-info "Unsupported Schema input" {:input input})))
-  (if-not (some #{:classpath-aware} params)
-    (SchemaLoader/load (JSONObject. (prepare-tokener input)))
-    (let [schema-loader (-> (SchemaLoader/builder)
-                            (.schemaClient (SchemaClient/classPathAwareClient))
-                            (.schemaJson (JSONObject. (prepare-tokener input)))
-                            (.build))]
-      (.build (.load schema-loader)))))
+  "Prepares JSON Schema based on input string or map. An optional parameter map
+  can be supplied to refer to relative file schemas via classpath in $ref fields.
+
+  Setting :classpath-aware? to true enables absolute classpath resolution.
+  (prepare-schema* input {:classpath-aware? true})
+
+  Setting :default-resolution-scope enables relative classpath resolution.
+  Make sure to not use HTTP URIs in schema $id fields, as this
+  will cause it to resort to default $ref resolution via HTTP.
+  (prepare-schema* input {:classpath-aware? true
+                          :default-resolution-scope \"classpath://schemas/\"})"
+  ([input]
+   (assert-schema-input-valid! input)
+   (SchemaLoader/load (JSONObject. (prepare-tokener input))))
+  ([input params]
+   (assert-schema-input-valid! input)
+   (if-not (:classpath-aware? params)
+     (prepare-schema* input)
+     (let [resolution-scope (:default-resolution-scope params)
+           set-resolution-scope (fn [client] (if resolution-scope
+                                               (.resolutionScope client resolution-scope)
+                                               client))
+           schema-loader (-> (SchemaLoader/builder)
+                             (.schemaClient (SchemaClient/classPathAwareClient))
+                             (set-resolution-scope)
+                             (.schemaJson (JSONObject. (prepare-tokener input)))
+                             (.build))]
+       (.build (.load schema-loader))))))
 
 (def ^JSONObject prepare-schema (memoize prepare-schema*))
 

test/json_schema/core_test.clj

@@ -130,18 +130,34 @@
              (json/validate schema json-edn-invalid)))))))
 
 (deftest classpath-ref-resolution
-  (testing "JSON Schema with classpath ref loading"
-    (let [schema-input (-> "person.json" io/resource slurp)
-          schema (json/prepare-schema schema-input :classpath-aware)
-          valid-input {:address {:street_address "Penguin Avenue 15"
+  (testing "JSON Schema validation with classpath ref resolution"
+    (let [valid-input {:address {:street_address "Penguin Avenue 15"
                                  :city "Vilnius"}}
           invalid-input {:address "Penguin Avenue 15, Vilnius"}]
 
-      (testing "valid EDN input for referred field via classpath VALIDATES"
-        (is (= valid-input (json/validate schema valid-input))))
+      (testing "Absolute classpath refs"
+        (let [schema-input (-> "ref/absolute/person.json" io/resource slurp)
+              schema (json/prepare-schema schema-input {:classpath-aware? true})]
 
-      (testing "invalid EDN input for referred field via classpath FAILS"
-        (is (thrown-with-msg?
-             Exception
-             #"JSON Validation error"
-             (json/validate schema invalid-input)))))))
+          (testing "valid EDN input for absolute classpath ref VALIDATES"
+            (is (= valid-input (json/validate schema valid-input))))
+
+          (testing "invalid EDN input for absolute classpath ref FAILS"
+            (is (thrown-with-msg?
+                  Exception
+                  #"JSON Validation error"
+                  (json/validate schema invalid-input))))))
+
+      (testing "Relative classpath refs"
+        (let [schema-input (-> "ref/relative/person.json" io/resource slurp)
+              schema (json/prepare-schema schema-input {:classpath-aware? true
+                                                        :default-resolution-scope "classpath://ref/relative/"})]
+
+          (testing "valid EDN input for relative classpath ref VALIDATES"
+            (is (= valid-input (json/validate schema valid-input))))
+
+          (testing "valid EDN input for relative classpath ref FAILS"
+            (is (thrown-with-msg?
+                  Exception
+                  #"JSON Validation error"
+                  (json/validate schema invalid-input)))))))))

test/resources/definitions.json renamed to test/resources/ref/absolute/definitions.json

@@ -5,7 +5,7 @@
   "type": "object",
   "properties": {
     "address": {
-      "$ref": "classpath://definitions.json#/definitions/address"
+      "$ref": "classpath://ref/absolute/definitions.json#/definitions/address"
     }
   },
   "required": ["address"]

test/resources/person.json renamed to test/resources/ref/absolute/person.json

@@ -0,0 +1,21 @@
+{
+  "$id": "Definitions",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "address": {
+      "type": "object",
+      "properties": {
+        "street_address": {
+          "type": "string"
+        },
+        "city": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "street_address",
+        "city"
+      ]
+    }
+  }
+}

test/resources/ref/relative/definitions.json

@@ -0,0 +1,12 @@
+{
+  "$id": "Person",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Person",
+  "type": "object",
+  "properties": {
+    "address": {
+      "$ref": "definitions.json#/definitions/address"
+    }
+  },
+  "required": ["address"]
+}