Initial commit for schema to openapi converter

Author: swallez

.editorconfig

@@ -2,4 +2,5 @@
 members = [
     "clients_schema",
     "openapi_to_clients_schema",
+    "clients_schema_to_openapi"
 ]

openapi-converter/Cargo.lock

@@ -9,6 +9,7 @@ serde = {version = "1.0", features=["derive"]}
 serde_json = "1.0"
 typed-builder = "0.11"
 once_cell = "1.16"
+anyhow = "1.0"
 
 [dev-dependencies]
 serde_path_to_error = "0.1"

openapi-converter/Cargo.toml

@@ -15,6 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::HashMap;
+use std::fmt::{Display, Formatter};
+use anyhow::bail;
 // Re-export crates whose types we expose publicly
 pub use once_cell;
 
@@ -30,7 +33,7 @@ const fn is_false(v: &bool) -> bool {
     !(*v)
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, PartialOrd, Hash)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Hash)]
 pub struct TypeName {
     pub namespace: String,
     pub name: String
@@ -44,6 +47,14 @@ impl TypeName {
         }
     }
 }
+
+impl Display for TypeName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}:{}", self.namespace, self.name)
+    }
+}
+
+
 ///
 /// Type of a value. Used both for property types and nested type definitions.
 ///
@@ -737,6 +748,10 @@ impl Model {
     pub fn from_reader(r: impl std::io::Read) -> Result<Self, serde_json::error::Error> {
         serde_json::from_reader(r)
     }
+
+    pub fn type_registry(&self) -> TypeRegistry {
+        TypeRegistry::new(self)
+    }
 }
 
 #[cfg(test)]
@@ -772,3 +787,45 @@ mod tests {
         };
     }
 }
+
+pub struct TypeRegistry<'a> {
+    types: HashMap<&'a TypeName, &'a TypeDefinition>
+}
+
+impl<'a> TypeRegistry<'a> {
+    pub fn new(model: &Model) -> TypeRegistry {
+        let types = model.types.iter()
+            .map(|typedef| (typedef.name(), typedef))
+            .collect::<HashMap<_,_>>();
+
+        TypeRegistry{ types }
+    }
+
+    pub fn get(&self, name: &TypeName) -> anyhow::Result<&'a TypeDefinition> {
+        match self.types.get(name) {
+            Some(typedef) => Ok(typedef),
+            None => bail!("No definition for type {}", name),
+        }
+    }
+
+    // pub fn get_interface(&self, name: &TypeName) -> anyhow::Result<&'a Interface> {
+    //     match self.get(name)? {
+    //         TypeDefinition::Interface(itf) => Ok(itf),
+    //         _ => bail!("Type {} is not an interface", name),
+    //     }
+    // }
+
+    pub fn get_request(&self, name: &TypeName) -> anyhow::Result<&'a Request> {
+        match self.get(name)? {
+            TypeDefinition::Request(req) => Ok(req),
+            _ => bail!("Type {} is not a request", name),
+        }
+    }
+
+    pub fn get_resppnse(&self, name: &TypeName) -> anyhow::Result<&'a Response> {
+        match self.get(name)? {
+            TypeDefinition::Response(resp) => Ok(resp),
+            _ => bail!("Type {} is not a response", name),
+        }
+    }
+}

openapi-converter/clients_schema/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "clients_schema_to_openapi"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clients_schema = {path="../clients_schema"}
+
+serde = {version = "1.0", features=["derive"]}
+serde_json = "1.0"
+serde_path_to_error = "0.1"
+serde_ignored = "0.1"
+openapiv3 = "1.0"
+anyhow = "1.0"
+indexmap = "1.9"
+convert_case = "0.6"
+either_n = "0.2.0"
+regex = "1.8"
+maplit = "1.0"
+
+tracing = "0.1.37"
+tracing-subscriber = "0.3.16"

openapi-converter/clients_schema/src/lib.rs

@@ -0,0 +1,67 @@
+mod paths;
+mod schemas;
+
+use std::io::Write;
+use std::path::Path;
+
+use clients_schema::{Model, Property, TypeDefinition, TypeName, TypeRegistry, ValueOf};
+
+pub fn convert_schema(path: impl AsRef<Path>, out: impl Write) -> anyhow::Result<()> {
+    let file = std::fs::File::open(path)?;
+
+    let model: Model = serde_json::from_reader(file)?;
+    let types = model.type_registry();
+
+    let mut openapi = openapiv3::OpenAPI::default();
+
+    openapi.openapi = "3.1.0".into();
+
+    openapi.info = openapiv3::Info {
+        title: "Elasticsearch API".to_string(),
+        description: None,
+        terms_of_service: None,
+        contact: None,
+        license: license(&model),
+        version: "".to_string(),
+        extensions: Default::default(),
+    };
+
+    // Endpoints
+    let paths = paths::build_paths(&model.endpoints, &types)?;
+
+    openapi.paths = openapiv3::Paths {
+        paths: paths,
+        extensions: Default::default(),
+    };
+
+    // Types
+    let components = openapiv3::Components {
+        security_schemes: Default::default(),
+        responses: Default::default(),
+        parameters: Default::default(),
+        examples: Default::default(),
+        request_bodies: Default::default(),
+        headers: Default::default(),
+        schemas: Default::default(),
+        links: Default::default(),
+        callbacks: Default::default(),
+        extensions: Default::default(),
+    };
+
+    openapi.components = Some(components);
+
+    serde_json::to_writer_pretty(out, &openapi)?;
+    Ok(())
+}
+
+fn license(model: &Model) -> Option<openapiv3::License> {
+    if let Some(info) = &model.info {
+        Some(openapiv3::License {
+            name: info.license.name.clone(),
+            url: Some(info.license.url.clone()),
+            extensions: Default::default(),
+        })
+    } else {
+        None
+    }
+}

openapi-converter/clients_schema_to_openapi/Cargo.toml

@@ -0,0 +1,7 @@
+fn main() {
+    clients_schema_to_openapi::convert_schema(
+        "../../elasticsearch-specification/output/schema/schema.json",
+        std::io::stdout()
+    ).unwrap();
+
+}