Deref does not dereference local references in an included schema

[jlutzhbo]

@bojand Thanks so much for your quick turnaround with fixes. Things are looking much better. I found one more issue though. Behold, the following simple test case:

    var testSchema = {
        "type": "object",
        "properties": {
            "foo": {
                "$ref": "urn:foo#/barArray"
            }
        }
    };

    var fooSchema = {
        "definitions": {
            "bar": {
                "type": "string"
            }
        },
        "barArray": {
            "type": "array",
            "item": {
                "$ref": "#/definitions/bar"
            }
        }
    };

Again, I am using my custom loader (whose code I posted here: #2), although I'm not sure if that is material to this problem. Note that when I run deref on testSchema, barArray gets resolved, but the local reference within fooSchema to definitions/bar does not.

Two thoughts: 1. this may require a slight design change because of the semantics of how the custom loader resolves a schema (resolves the local path within the schema and doesn't return the full schema). 2. I may be able to work around this by running deref on a schema before returning it, although it would be nice to not have to do this.

Thanks for looking into this!

[bojand]

Presently the expectation is that the custom loader would return exactly what the resolution of $ref should be.

So for "$ref": "urn:foo#/barArray" your custom loader should returns exactly what that should be. Not the full schema, with the expectation that the rest of the path in $ref will be resolved automatically. This is so because there would be ambiguity about what the behaviour of the loader is doing otherwise.

I have been thinking of how to better accommodate different scenarios of custom loader but not sure of a good solution. For something that you have right now, a workaround is something like what I added to unit tests. Your schema could be:

{
  "type": "object",
  "definitions": {
    "custom": {
      "$ref": "urn:custom"
    }
  },
  "properties": {
    "bar": {
      "$ref": "#/definitions/custom/fooDef1"
    }
  }
}

Your custom loader will return the custom schema, and it should get deref'ed itself if needed. Then the actual property will be resolved correctly.

There are a few more improvements I have in mind / plans for the lib, will try to get those in sometime, which may help address these kind of issues. But in order to do it I think I also have to add a way to handle circular dependencies more gracefully, which it doesn't right now.

[bpytlik]

I have hit this same issue without a custom loader. I created two schema files (based off the example above). schema1.json:

{
        "type": "object",
        "properties": {
            "foo": {
                "$ref": "schema2.json#/barArray"
            }
        }
    }

schema2.json:

{
        "definitions": {
            "bar": {
                "type": "string"
            }
        },
        "barArray": {
            "type": "array",
            "item": {
                "$ref": "#/definitions/bar"
            }
        }
    }

Result:

{
    "type": "object",
    "properties": {
        "foo": {
            "type": "array",
            "item": {
                "$ref": "#/definitions/bar"
            }
        }
    }
}

So I don't think this is an issue restricted only to custom loaders. I suspect it's an issue with multiple schemas.

Here's what getRefSchema returns for the relevant bit (gotten by instrumenting the JS code):

refVal:
schema2.json#/barArray
getRefSchema, newValue:
{ type: 'array', item: { '$ref': '#/definitions/bar' } }

[schmkr]

I also encountered this issue, not using any custom loaders. Actually I'm using json-schema-deref-sync, but the result is the same:

schema A has a reference to a property in schema B. That property in schema B contains a reference to another property in schema B, but the dereferenced result now has ref to that property in schema A (which does not exist).

[bojand]

I'll have to take a look when I get a little bit more time. Hopefully soon.

[mmorga]

I can report that I'm seeing the same thing. It looks like local references in a a deref'd schema are not being dereferenced.

[mmorga]

Digging a little deeper, the issue is that when parsing a schema loaded via the file loader, when getRefSchema is called on the $ref, the "parent" param is not the full file of the loaded schema, but is instead a sub-set and the $ref isn't found.

[bojand]

I believe I had a fix for something similar in this branch:

https://github.com/bojand/json-schema-deref-sync/compare/full-schema-loader-return

I'll have to take a look if all tests pass, and if it fixes this issue. I believe it still causes issues because we don't detect circular refs / dependencies (another issue altogether I suppose) so I left it out because I wanted to add that in or something.

I am just pretty swamped right now to dig deeper. Hopefully soon.