Adding typescript type endpoint and fixing ts types

integrationos-api/src/endpoints/schema_generator.rs

@@ -7,14 +7,17 @@ use axum::{
 };
 use bson::{doc, Document};
 use futures::StreamExt;
-use integrationos_domain::{ApplicationError, Id, IntegrationOSError, InternalError, Store};
+use integrationos_domain::{
+    api_model_config::Lang, ApplicationError, Id, IntegrationOSError, InternalError, Store,
+};
 use mongodb::options::FindOptions;
 use std::sync::Arc;
 
 pub fn get_router() -> Router<Arc<AppState>> {
     Router::new()
         .route("/projection", get(get_common_model_proj))
         .route("/:id", get(generate_schema))
+        .route("/types/:id", get(generate_types))
 }
 
 pub async fn get_common_model_proj(
@@ -61,6 +64,29 @@ pub async fn get_common_model_proj(
     }))
 }
 
+pub async fn generate_types(
+    state: State<Arc<AppState>>,
+    Path(id): Path<Id>,
+) -> Result<String, IntegrationOSError> {
+    let cm_store = state.app_stores.common_model.clone();
+    let ce_store = state.app_stores.common_enum.clone();
+
+    let common_model = cm_store
+        .get_one_by_id(&id.to_string())
+        .await
+        .map_err(IntegrationOSError::from)?
+        .ok_or(ApplicationError::not_found(
+            &format!("CommonModel with id {} not found", id),
+            None,
+        ))?;
+
+    let schema = common_model
+        .generate_as_expanded(&Lang::TypeScript, &cm_store, &ce_store)
+        .await;
+
+    Ok(schema)
+}
+
 pub async fn generate_schema(
     state: State<Arc<AppState>>,
     Path(id): Path<Id>,

integrationos-domain/src/domain/schema/common_model.rs

@@ -187,6 +187,32 @@ impl CommonEnum {
         )
     }
 
+    pub fn as_typescript_type(&self) -> String {
+        // let's add the value directly to the enum
+        format!(
+            "export const enum {} {{ {} }}\n",
+            replace_reserved_keyword(&self.name, Lang::TypeScript)
+                .replace("::", "")
+                .pascal_case(),
+            self.options
+                .iter()
+                .map(|option| {
+                    let option_name = option.pascal_case();
+                    let option_value = if option.chars().all(char::is_uppercase) {
+                        option.to_lowercase()
+                    } else {
+                        option.kebab_case()
+                    };
+
+                    format!("{} = '{}'", option_name, option_value)
+                })
+                .collect::<HashSet<String>>()
+                .into_iter()
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    }
+
     /// Generates a effect Schema for the enum
     pub fn as_typescript_schema(&self) -> String {
         let name = replace_reserved_keyword(&self.name, Lang::TypeScript)
@@ -220,22 +246,6 @@ impl CommonEnum {
 
         format!("{}\n{}", native_enum, schema)
     }
-
-    pub fn as_typescript_type(&self) -> String {
-        format!(
-            "export const enum {} {{ {} }}\n",
-            replace_reserved_keyword(&self.name, Lang::TypeScript)
-                .replace("::", "")
-                .pascal_case(),
-            self.options
-                .iter()
-                .map(|option| option.pascal_case())
-                .collect::<HashSet<String>>()
-                .into_iter()
-                .collect::<Vec<_>>()
-                .join(", ")
-        )
-    }
 }
 
 impl DataType {
@@ -625,10 +635,6 @@ impl CommonModel {
         }
     }
 
-    pub fn generate_as_typescript_schema(&self) -> String {
-        self.as_typescript_schema()
-    }
-
     /// Generates the model as a string in the specified language
     /// with recursively expanded inner models and enums.
     /// This is useful for generating the entire model and its