Any sample for array of object items?

[bwgjoseph]

Given an example of the following schema

{
	"$schema": "http://json-schema.org/draft-07/schema",
	"type": "object",
	"properties": {
		"number": {
			"type": "number"
		},
		"street_name": {
			"type": "string"
		},
		"street_type": {
			"enum": [
				"Street",
				"Avenue",
				"Boulevard"
			]
		},
		"vegetables": {
			"type": "array",
			"items": {
				"veggie": {
					"type": "object",
					"required": [
						"veggieName",
						"veggieLike"
					],
					"properties": {
						"veggieName": {
							"type": "string",
							"description": "The name of the vegetable."
						},
						"veggieLike": {
							"type": "boolean",
							"description": "Do I like this vegetable?"
						}
					}
				}
			}
		}
	},
	"additionalProperties": false
}

I took the sample from https://json-schema.org/learn/miscellaneous-examples.html#arrays-of-things but without $defs

What's currently showing for me is

I don't see such example at https://jy95.github.io/docusaurus-json-schema-plugin/docs/category/-array as well

Wondering if this is the correct display?

Thanks!

[jy95]

When I copy the https://json-schema.org/learn/miscellaneous-examples.html#arrays-of-things on the playground, I got the expected result :

In fact, you made a small mistake when removing $defs , that is why you get that wrong view.

Correct schema :

{
	"$schema": "http://json-schema.org/draft-07/schema",
	"type": "object",
	"properties": {
		"number": {
			"type": "number"
		},
		"street_name": {
			"type": "string"
		},
		"street_type": {
			"enum": [
				"Street",
				"Avenue",
				"Boulevard"
			]
		},
		"vegetables": {
			"type": "array",
			"items": {
				"type": "object",
				"required": [
					"veggieName",
					"veggieLike"
				],
				"properties": {
					"veggieName": {
						"type": "string",
						"description": "The name of the vegetable."
					},
					"veggieLike": {
						"type": "boolean",
						"description": "Do I like this vegetable?"
					}
				}
			}
		}
	},
	"additionalProperties": false
}

[bwgjoseph]

Thanks, indeed I copied an extra key.

Now it shows correctly on my end as well.

[bwgjoseph]

hey @jy95,

are you aware of how does the $ref and $defs get parsed?

I'm trying out this

{
    "$jsonSchema": {
        "bsonType": "object",
        "required": [ "name", "address" ],
        "properties": {
            "name": {
                "bsonType": "string",
                "description": "must be a string and is required"
            },
            "address": {
                "bsonType": "object",
                "required": [ "zipcode" ],
                "properties": {
                    "street": { "bsonType": "string" },
                    "zipcode": { "bsonType": "string" }
                }
            },
            "vegetables": {
                "bsonType": "array",
                "items": { "$ref": "#/$defs/veggie" }
            },
            "fruits": {
                "bsonType": "array",
                "items": {
                  "bsonType": "string"
                }
            }
        },
        "$defs": {
            "veggie": {
              "bsonType": "object",
              "required": [ "veggieName", "veggieLike" ],
              "properties": {
                "veggieName": {
                  "bsonType": "string",
                  "description": "The name of the vegetable."
                },
                "veggieLike": {
                  "bsonType": "boolean",
                  "description": "Do I like this vegetable?"
                }
              }
            }
        }
    }
}

I'm not sure how to parse it, do I replace whatever is in the "$ref": "#/$defs/veggie" with the actual content in the $defs.

Thanks

[bwgjoseph]

Here you go

{
    "type": "object",
    "required": [
        "name",
        "address"
    ],
    "properties": {
        "name": {
            "type": "string",
            "description": "must be a string and is required"
        },
        "address": {
            "type": "object",
            "required": [
                "zipcode"
            ],
            "properties": {
                "street": {
                    "type": "string"
                },
                "zipcode": {
                    "type": "string"
                }
            }
        },
        "vegetables": {
            "type": "array",
            "items": {
                "$ref": "#/$jsonSchema/$defs/veggie"
            }
        },
        "fruits": {
            "type": "array",
            "items": {
                "type": "string"
            }
        }
    },
    "$defs": {
        "veggie": {
            "type": "object",
            "required": [
                "veggieName",
                "veggieLike"
            ],
            "properties": {
                "veggieName": {
                    "type": "string",
                    "description": "The name of the vegetable."
                },
                "veggieLike": {
                    "type": "boolean",
                    "description": "Do I like this vegetable?"
                }
            }
        }
    }
}

[jy95]

Again, it confirms what I thought : Check the $ref carefully with for example a JSON Schema validator

Wrong :

        "vegetables": {
            "type": "array",
            "items": {
                "$ref": "#/$jsonSchema/$defs/veggie"
            }
        },

Correct :

		"vegetables": {
   		"type": "array",
   		"items": {
   			"$ref": "#/$defs/veggie"
   		}
   	},

With that single change, it works as expected

Maybe I should enable validation (if it is possible with Monaco editor) on playground so that such errors are avoided ...

[bwgjoseph]

Thanks for being patient with me.

Firstly, the validator works for both variation.

Secondly, I made the change to #/$jsonSchema/$defs/veggie based on what you have mentioned above - #31 (reply in thread)

Thirdly, I think there is a small difference of your example and mine. Your $defs was outside "#/definitions/user" while mine is inside (see the next json for the full output)

{
    "$jsonSchema": {
        "bsonType": "object",
        "required": [ "name", "address" ],
        "properties": {
            "name": {
                "bsonType": "string",
                "description": "must be a string and is required"
            },
            "address": {
                "bsonType": "object",
                "required": [ "zipcode" ],
                "properties": {
                    "street": { "bsonType": "string" },
                    "zipcode": { "bsonType": "string" }
                }
            },
            "vegetables": {
                "bsonType": "array",
                "items": {
                    "$ref": "#/$defs/veggie"
                }
            },
            "fruits": {
                "bsonType": "array",
                "items": {
                  "bsonType": "string"
                }
            }
        },
        "$defs": {
            "veggie": {
              "type": "object",
              "required": [ "veggieName", "veggieLike" ],
              "properties": {
                "veggieName": {
                  "type": "string",
                  "description": "The name of the vegetable."
                },
                "veggieLike": {
                  "type": "boolean",
                  "description": "Do I like this vegetable?"
                }
              }
            }
        }
    }
}

But I do realize that I may not have shown the full picture, thus causing some confusion. When you mentioned that you wish to see the converted schema, I understood and pasted the converted schema but not the entire object, but this is actually the one that returns. Notice that somehow, $defs is still within definitions.mongoDB and not at the root like the one in your example.

{
    "$ref": "#/definitions/mongoDB",
    "definitions": {
        "mongoDB": {
            "type": "object",
            "required": [
                "name",
                "address"
            ],
            "properties": {
                "name": {
                    "type": "string",
                    "description": "must be a string and is required"
                },
                "address": {
                    "type": "object",
                    "required": [
                        "zipcode"
                    ],
                    "properties": {
                        "street": {
                            "type": "string"
                        },
                        "zipcode": {
                            "type": "string"
                        }
                    }
                },
                "vegetables": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/veggie"
                    }
                },
                "fruits": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            },
            "$defs": {
                "veggie": {
                    "type": "object",
                    "required": [
                        "veggieName",
                        "veggieLike"
                    ],
                    "properties": {
                        "veggieName": {
                            "type": "string",
                            "description": "The name of the vegetable."
                        },
                        "veggieLike": {
                            "type": "boolean",
                            "description": "Do I like this vegetable?"
                        }
                    }
                }
            }
        }
    }
}

So previously, I returned like such in my convert.js

return {
        "$ref": "#/definitions/mongoDB",
        "definitions": {
            "mongoDB": convertedSchema
        }
    }

But now, if I want it to appear at the root, I return like

return {
        "$ref": "#/definitions/mongoDB",
        "definitions": {
            "mongoDB": convertedSchema
        },
        "#defs": convertedSchema.$defs
    }

Which unfortunately is still not working.

I'm guessing I'm missing something obvious but can't quite get it

Thanks for your time on this

[jy95]

Ok, so at the end, two scenarios :

1. definitions, $defs and $root at root level

{
	"$ref": "#/definitions/mongoDB",
	"definitions": {
		"mongoDB": {
			"type": "object",
			"required": [
				"name",
				"address"
			],
			"properties": {
				"name": {
					"type": "string",
					"description": "must be a string and is required"
				},
				"address": {
					"type": "object",
					"required": [
						"zipcode"
					],
					"properties": {
						"street": {
							"type": "string"
						},
						"zipcode": {
							"type": "string"
						}
					}
				},
				"vegetables": {
					"type": "array",
					"items": {
						"$ref": "#/$defs/veggie"
					}
				},
				"fruits": {
					"type": "array",
					"items": {
						"type": "string"
					}
				}
			}
		}
	},
	"$defs": {
		"veggie": {
			"type": "object",
			"required": [
				"veggieName",
				"veggieLike"
			],
			"properties": {
				"veggieName": {
					"type": "string",
					"description": "The name of the vegetable."
				},
				"veggieLike": {
					"type": "boolean",
					"description": "Do I like this vegetable?"
				}
			}
		}
	}
}

If I copy that to the playground, you can see it works :

2. $defs is still within definitions.mongoDB

In that case, you need to update your local $refs (such as vegetables items ) to reflect the final path.

{
    "$ref": "#/definitions/mongoDB",
    "definitions": {
        "mongoDB": {
            "type": "object",
            "required": [
                "name",
                "address"
            ],
            "properties": {
                "name": {
                    "type": "string",
                    "description": "must be a string and is required"
                },
                "address": {
                    "type": "object",
                    "required": [
                        "zipcode"
                    ],
                    "properties": {
                        "street": {
                            "type": "string"
                        },
                        "zipcode": {
                            "type": "string"
                        }
                    }
                },
                "vegetables": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/mongoDB/$defs/veggie"
                    }
                },
                "fruits": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            },
            "$defs": {
                "veggie": {
                    "type": "object",
                    "required": [
                        "veggieName",
                        "veggieLike"
                    ],
                    "properties": {
                        "veggieName": {
                            "type": "string",
                            "description": "The name of the vegetable."
                        },
                        "veggieLike": {
                            "type": "boolean",
                            "description": "Do I like this vegetable?"
                        }
                    }
                }
            }
        }
    }
}

If I copy that to the playground, you can see it works :

My suggestion is to edit the convertObject I provided in previous discussion to handle that properly

function convertObject(schema) {
    const convertedSchema = {};
    for (const key in schema) {
        if (key === "$ref" && schema[key].startsWith("#")) {
            // Why substring(2) ? because I need to remove "#/" from previous string
            convertedSchema[key] = "#/definitions/mongoDB/"+ schema[key].substring(2);
        } else if (key === "exclusiveMinimum" && schema[key] === true) {
            convertedSchema["exclusiveMinimum"] = schema["minimum"];
        } else if (key === "exclusiveMaximum" && schema[key] === true) {
            convertedSchema["exclusiveMaximum"] = schema["maximum"];
        } else if (key === "bsonType") {
            if (Array.isArray(schema[key])) {
                convertedSchema["type"] = "array";
                convertedSchema["items"] = schema[key].map(convertBsonType);
            } else {
                const bsonType = schema[key];
                if (DRAFT_07_TYPES.includes(bsonType)) {
                    convertedSchema["type"] = bsonType;
                } else {
                    convertedSchema["type"] = "string";
                    convertedSchema["format"] = bsonType;
                }
            }
        } else if (key === "properties") {
            convertedSchema[key] = convertObject(schema[key]);
        } else if (key === "additionalProperties") {
            if (schema[key] === false) {
                convertedSchema[key] = false;
            } else if (typeof schema[key] === "object") {
                convertedSchema[key] = convertObject(schema[key]);
            }
        } else if (key === "items") {
            if (Array.isArray(schema[key])) {
                convertedSchema[key] = schema[key].map(convertBsonType);
            } else if (typeof schema[key] === "object") {
                convertedSchema[key] = convertBsonType(schema[key]);
            }
        } else {
            convertedSchema[key] = schema[key];
        }
    }
    return convertedSchema;
}

[bwgjoseph]

Thanks!

I was actually missing the #/definitions/mongoDB/ prefix when declaring #/definitions/mongoDB/$defs/veggie. I got it to work now, although I still can't quite get option 1 to work if I had defined $ref at root, changing to #/$defs/veggie didn't help. But I think that's fine since I will likely use option 2 more.

Also, I did not use your script exactly since it (the generated one) didn't handle some of the cases as well, so I built mine on top of what you have, only to ensure it handle some other use case that was not. Still ironing out something, but will share the function later when it's done.

Again, thank you for helping out. Appreciate it!