add tests

fix: #90

Author: mlewando

dist/index.js

@@ -0,0 +1,101 @@
+import { compileSchema } from "../../compileSchema";
+import { getSchemaType } from "../../utils/getSchemaType";
+import { strict as assert } from "assert";
+
+describe("issue#90 - types or refs", () => {
+    it("should get correct type for simple ref", () => {
+        const schema = compileSchema({
+            type: "object",
+            $defs: {
+                customConst: {
+                    type: "string"
+                }
+            },
+            properties: {
+                name: { $ref: "#/$defs/customConst" }
+            }
+        });
+        const nameProp = schema.getNodeChild("name").node;
+        assert(nameProp != null);
+        assert(getSchemaType(nameProp, undefined) === "string");
+    });
+
+    it("should handle oneOf refs", () => {
+        const schema = compileSchema({
+            type: "object",
+            $defs: {
+                a: {
+                    type: "string",
+                    const: "a"
+                },
+                b: {
+                    type: "string",
+                    const: "b"
+                }
+            },
+
+            properties: {
+                oneOf: {
+                    oneOf: [{ $ref: "#/$defs/a" }, { $ref: "#/$defs/b" }]
+                }
+            }
+        });
+        const oneOfProp = schema.getNodeChild("oneOf").node;
+        assert(oneOfProp != null);
+        assert(getSchemaType(oneOfProp, undefined) === "string");
+    });
+    it("should handle anyOf refs", () => {
+        const schema = compileSchema({
+            type: "object",
+            $defs: {
+                a: { type: "string", const: "a" },
+                b: { type: "string", const: "b" }
+            },
+            properties: {
+                anyOf: {
+                    anyOf: [{ $ref: "#/$defs/a" }, { $ref: "#/$defs/b" }]
+                }
+            }
+        });
+        const anyOfProp = schema.getNodeChild("anyOf").node;
+        assert(anyOfProp != null);
+        assert(getSchemaType(anyOfProp, undefined) === "string");
+    });
+    it("should handle allOf refs", () => {
+        const schema = compileSchema({
+            type: "object",
+            $defs: {
+                a: { type: "object", properties: { a: { type: "string" } } },
+                b: { type: "object", properties: { b: { type: "string" } } }
+            },
+            properties: {
+                allOf: {
+                    allOf: [{ $ref: "#/$defs/a" }, { $ref: "#/$defs/b" }]
+                }
+            }
+        });
+        const allOfProp = schema.getNodeChild("allOf").node;
+        assert(allOfProp != null);
+        assert(getSchemaType(allOfProp, undefined) === "object");
+    });
+    it("should handle if/then/else refs", () => {
+        const schema = compileSchema({
+            type: "object",
+            $defs: {
+                stringSchema: {
+                    type: "string"
+                }
+            },
+            properties: {
+                conditional: {
+                    if: { $ref: "#/$defs/stringSchema" },
+                    then: { minLength: 5 },
+                    else: { maxLength: 2 }
+                }
+            }
+        });
+        const conditionalProp = schema.getNodeChild("conditional").node;
+        assert(conditionalProp != null);
+        assert(getSchemaType(conditionalProp, undefined) === "string");
+    });
+});

dist/index.mjs

@@ -106,12 +106,12 @@ export function getSchemaType(node: SchemaNode, data: unknown): SchemaType | und
 
     // nothing found yet check dynamic properties for a type
     if (node.if) {
-        return getSchemaType(node.if.resolveRef?.() ?? node.if, data);
+        return getSchemaType(node.if.getNode("#", data)?.node ?? node.if, data);
     }
 
     if (node.allOf) {
         for (let i = 0; i < node.allOf.length; i += 1) {
-            const type = getSchemaType(node.allOf[i].resolveRef?.() ?? node.allOf[i], data);
+            const type = getSchemaType(node.allOf[i].getNode("#", data)?.node ?? node.allOf[i], data);
             if (type) {
                 return type;
             }
@@ -120,7 +120,7 @@ export function getSchemaType(node: SchemaNode, data: unknown): SchemaType | und
 
     if (node.oneOf) {
         for (let i = 0; i < node.oneOf.length; i += 1) {
-            const type = getSchemaType(node.oneOf[i].resolveRef?.() ?? node.oneOf[i], data);
+            const type = getSchemaType(node.oneOf[i].getNode("#", data)?.node ?? node.oneOf[i], data);
             if (type) {
                 return type;
             }
@@ -129,12 +129,19 @@ export function getSchemaType(node: SchemaNode, data: unknown): SchemaType | und
 
     if (node.anyOf) {
         for (let i = 0; i < node.anyOf.length; i += 1) {
-            const type = getSchemaType(node.anyOf[i].resolveRef?.() ?? node.anyOf[i], data);
+            const type = getSchemaType(node.anyOf[i].getNode("#", data)?.node ?? node.anyOf[i], data);
             if (type) {
                 return type;
             }
         }
     }
 
+    if (schema.$ref) {
+        const refNode = node.getNode("#", data)?.node;
+        if (refNode) {
+            return getSchemaType(refNode, data);
+        }
+    }
+
     return undefined;
 }