Monaco editor fails to offer all valid completions for a string/enum property

[stanislawosinski]

For a schema that uses oneOf to implement polymorphic types, Monaco sometimes fails to offer completions for all valid values of a string/enum property.

When I use the following JSON schema:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "definitions": {
    "component1.1": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "component1.1"
          ]
        },
        "prop1.1": {
          "type": "integer"
        }
      },
      "required": [
        "type"
      ]
    },
    "component1.2": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "component1.2"
          ]
        },
        "prop1.2": {
          "type": "integer"
        }
      },
      "required": [
        "type",
        "prop1.2"
      ]
    },
    "component1": {
      "oneOf": [
        {
          "$ref": "#/definitions/component1.1"
        },
        {
          "$ref": "#/definitions/component1.2"
        }
      ]
    }
  },
  "properties": {
    "component": {
      "$ref": "#/definitions/component1"
    }
  }
}

and when the contents of the editor is:

{
  "component": {
      "type": ""
  }
}

I'd expect Monaco to offer two auto-complete options for the type property: component1.1 and component1.2. However, for the above schema, only component1.1 is shown in the auto-complete box. (The full playground reproduction code is included at the bottom.)

Interestingly, when I edit the definition of component1.1 to make the prop1.1 property required, Monaco behaves correctly and offers both type values (Working definition 1 below). Also, when I make the prop1.2 property not required (Working definition 2 below), I'm also getting the correct behavior.

Is this inconsistency in auto-complete somehow justified?

Working definition 1

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "definitions": {
    "component1.1": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "component1.1"
          ]
        },
        "prop1.1": {
          "type": "integer"
        }
      },
      "required": [
        "type", "prop1.1"
      ]
    },
    "component1.2": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "component1.2"
          ]
        },
        "prop1.2": {
          "type": "integer"
        }
      },
      "required": [
        "type",
        "prop1.2"
      ]
    },
    "component1": {
      "oneOf": [
        {
          "$ref": "#/definitions/component1.1"
        },
        {
          "$ref": "#/definitions/component1.2"
        }
      ]
    }
  },
  "properties": {
    "component": {
      "$ref": "#/definitions/component1"
    }
  }
}

Working definition 2

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "definitions": {
    "component1.1": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "component1.1"
          ]
        },
        "prop1.1": {
          "type": "integer"
        }
      },
      "required": [
        "type"
      ]
    },
    "component1.2": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "component1.2"
          ]
        },
        "prop1.2": {
          "type": "integer"
        }
      },
      "required": [
        "type"
      ]
    },
    "component1": {
      "oneOf": [
        {
          "$ref": "#/definitions/component1.1"
        },
        {
          "$ref": "#/definitions/component1.2"
        }
      ]
    }
  },
  "properties": {
    "component": {
      "$ref": "#/definitions/component1"
    }
  }
}

monaco-editor version: 0.21.2
Browser: Chrome
OS: Windows 10
Playground code that reproduces the issue:

var jsonCode = `{
  "component": {
      "type": ""
  }
}`;
var modelUri = monaco.Uri.parse("a://b/foo.json"); // a made up unique URI for our model
var model = monaco.editor.createModel(jsonCode, "json", modelUri);

// configure the JSON language support with schemas and schema associations
monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
    validate: true,
    schemas: [{
        uri: "http://myserver/foo-schema.json", // id of the first schema
        fileMatch: [modelUri.toString()], // associate with our model
        schema: {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "type": "object",
            "definitions": {
                "component1.1": {
                    "type": "object",
                    "properties": {
                        "type": {
                            "type": "string",
                            "enum": [
                                "component1.1"
                            ]
                        },
                        "prop1.1": {
                            "type": "integer"
                        }
                    },
                    "required": [
                        "type"
                    ]
                },
                "component1.2": {
                    "type": "object",
                    "properties": {
                        "type": {
                            "type": "string",
                            "enum": [
                                "component1.2"
                            ]
                        },
                        "prop1.2": {
                            "type": "integer"
                        }
                    },
                    "required": [
                        "type",
                        "prop1.2"
                    ]
                },
                "component1": {
                    "oneOf": [
                        {
                            "$ref": "#/definitions/component1.1"
                        },
                        {
                            "$ref": "#/definitions/component1.2"
                        }
                    ]
                }
            },
            "properties": {
                "component": {
                    "$ref": "#/definitions/component1"
                }
            }
        }
    }]
});

monaco.editor.create(document.getElementById("container"), {
    model: model
});

[aeschli]

Because of the unfulfilled "required": [ "type", "prop1.2"], the first variant gets more weight and is preferred.

[stanislawosinski]

Thanks for the explanation. I wouldn't mind the sorting order depending on the preference determined by the number of missing required properties, but the fact that the "component1.2" suggestion does not appear at all effectively "hides" this variant from the user. Is there any workaround (apart from changing the schema) I could use to have both variants present in the autocomplete list?

[aeschli]

It shows if there's no value at all, but as soon as there's a value, the second variant is gone.

Sorry, need to be fixed in code.

[stanislawosinski]

All right, good to know. Looking forward to the fix then!

[abdalla-rko]

I still have the same problem. Is there still no fix or way to fix this?

[stanislawosinski]

One workaround I've found is to add an explicit list of the allowed property (the type property in my example) values to the polymorphic oneOf definition:

"component1": {
    // workaround start
    "properties": {
        "type": {
            "type": "String",
            "enum": [
                "component1.1",
                "component1.2"
            ]
        }
    },
    "required": [ "type" ],
    // workaround end
    "oneOf": [
        {
            "$ref": "#/definitions/component1.1"
        },
        {
            "$ref": "#/definitions/component1.2"
        }
    ]
}

The complete working Monaco playground example with workaround

var jsonCode = `{
  "component": {
      "type": ""
  }
}`;
var modelUri = monaco.Uri.parse("a://b/foo.json"); // a made up unique URI for our model
var model = monaco.editor.createModel(jsonCode, "json", modelUri);

// configure the JSON language support with schemas and schema associations
monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
    validate: true,
    schemas: [{
        uri: "http://myserver/foo-schema.json", // id of the first schema
        fileMatch: [modelUri.toString()], // associate with our model
        schema: {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "type": "object",
            "definitions": {
                "component1.1": {
                    "type": "object",
                    "properties": {
                        "type": {
                            "type": "string",
                            "enum": [
                                "component1.1"
                            ]
                        },
                        "prop1.1": {
                            "type": "integer"
                        }
                    },
                    "required": [
                        "type"
                    ]
                },
                "component1.2": {
                    "type": "object",
                    "properties": {
                        "type": {
                            "type": "string",
                            "enum": [
                                "component1.2"
                            ]
                        },
                        "prop1.2": {
                            "type": "integer"
                        }
                    },
                    "required": [
                        "type",
                        "prop1.2"
                    ]
                },
                "component1": {
                    "properties": {
                        "type": {
                            "type": "String",
                            "enum": [
                                "component1.1",
                                "component1.2"
                            ]
                        }
                    },
                    "required": [ "type" ],
                    "oneOf": [
                        {
                            "$ref": "#/definitions/component1.1"
                        },
                        {
                            "$ref": "#/definitions/component1.2"
                        }
                    ]
                }
            },
            "properties": {
                "component": {
                    "$ref": "#/definitions/component1"
                }
            }
        }
    }]
});

monaco.editor.create(document.getElementById("container"), {
    model: model
});

The cleanest solution is probably to write a piece of JavaScript that would patch the schema at runtime, just before feeding the schema to Monaco.

[SnirBroshi]

Similar problem but not with enums:

Schema:

{
    "oneOf": [
        {
            "properties": {
                "action": { "type": "string", "pattern": "random" },
                "value": { "type": "integer" }
            },
            "required": ["value"]
        },
        {
            "properties": {
                "action": { "type": "string", "pattern": "argInteger" },
                "arg": { "type": "integer", "description": "integer" }
            },
            "required": ["arg"]
        },
        {
            "properties": {
                "action": { "type": "string", "pattern": "argString" },
                "arg": { "type": "string", "description": "string" }
            },
            "required": ["arg"]
        }
    ]
}

Document:

{
    "action": "argString",
}

Triggering completions under the action property gives only the arg or argInteger which autocompletes to "arg": 0, instead of "arg": "" which is to be expected.

This is because of the requireds that make the oneOf not match anything, but the arg of argInteger hides the arg of argString since they share a name.

[rahulbanerjee26]

Any updates on this?