take first object if no root

src/bin/cli.rs

@@ -172,9 +172,7 @@ fn convert(args: ConvertArgs) -> Result<(), Box<dyn Error>> {
 
     // Render the template.
     let rendered = match args.template {
-        Templates::JsonSchema => model.json_schema(args.root.expect(
-            "Root object name is required. Please add --root <object_name> or -r <object_name>",
-        )),
+        Templates::JsonSchema => model.json_schema(args.root),
         _ => render_jinja_template(&args.template, &mut model)?,
     };
 
@@ -304,7 +302,7 @@ mod tests {
     }
 
     #[test]
-    fn test_invalid_conversion() {
+    fn test_json_schema_no_root() {
         let mut cmd = Command::cargo_bin("md-models").unwrap();
         let assert = cmd
             .arg("convert")
@@ -313,7 +311,7 @@ mod tests {
             .arg("-t")
             .arg("json-schema")
             .assert();
-        assert.failure();
+        assert.success();
     }
 
     #[test]

src/datamodel.rs

@@ -71,16 +71,20 @@ impl DataModel {
     // # Returns
     //
     // A JSON schema string
-    pub fn json_schema(&self, obj_name: String) -> String {
+    pub fn json_schema(&self, obj_name: Option<String>) -> String {
         if self.objects.is_empty() {
             panic!("No objects found in the markdown file");
         }
 
-        if self.objects.iter().all(|o| o.name != obj_name) {
-            panic!("Object not found in the markdown file");
+        match obj_name {
+            Some(name) => {
+                if self.objects.iter().all(|o| o.name != name) {
+                    panic!("Object not found in the markdown file");
+                }
+                schema::to_json_schema(&name, self)
+            }
+            None => schema::to_json_schema(&self.objects[0].name, self),
         }
-
-        schema::to_json_schema(&obj_name, self)
     }
 
     // Get the JSON schema for all objects in the markdown file

tests/integration_tests.rs

@@ -109,13 +109,32 @@ mod tests {
     }
 
     #[test]
-    fn test_json_schema() {
+    fn test_json_schema_known_obj() {
         // Arrange
         let path = Path::new("tests/data/model.md");
         let model = DataModel::from_markdown(path).expect("Could not parse markdown");
 
         // Act
-        let schema = model.json_schema("Test".to_string());
+        let schema = model.json_schema(Some("Test".to_string()));
+        let schema: serde_json::Value = serde_json::from_str(&schema).unwrap();
+
+        // Assert
+        let expected_schema =
+            std::fs::read_to_string("tests/data/expected_json_schema.json").unwrap();
+        // Parse with serde_json
+        let expected_schema: serde_json::Value = serde_json::from_str(&expected_schema).unwrap();
+
+        assert_eq!(schema, expected_schema);
+    }
+
+    #[test]
+    fn test_json_schema_unknown_obj() {
+        // Arrange
+        let path = Path::new("tests/data/model.md");
+        let model = DataModel::from_markdown(path).expect("Could not parse markdown");
+
+        // Act
+        let schema = model.json_schema(None);
         let schema: serde_json::Value = serde_json::from_str(&schema).unwrap();
 
         // Assert
@@ -134,7 +153,7 @@ mod tests {
         let model = mdmodels::datamodel::DataModel::new(None, None);
 
         // Act
-        model.json_schema("Test".to_string());
+        model.json_schema(Some("Test".to_string()));
     }
 
     #[test]
@@ -145,7 +164,7 @@ mod tests {
         let model = DataModel::from_markdown(path).expect("Could not parse markdown");
 
         // Act
-        model.json_schema("Test3".to_string());
+        model.json_schema(Some("Test3".to_string()));
     }
 
     #[test]
@@ -191,7 +210,7 @@ mod tests {
             let obj_name = filename.replace(".json", "");
             let expected_schema =
                 std::fs::read_to_string(format!("tests/intermediates/{}", filename)).unwrap();
-            let schema = model.json_schema(obj_name);
+            let schema = model.json_schema(Some(obj_name));
 
             assert_eq!(
                 serde_json::from_str::<serde_json::Value>(schema.as_str())