Impelement find

Author: owjs3901

Cargo.lock

@@ -218,6 +218,9 @@ describe.sequential('sqlite', async () => {
         ],
       )
 
+      const allUsers = await pool.find(User)
+      expect(allUsers).toEqual([user, user2])
+
       await pool.transaction(async (ac) => {
         await pool.delete(user2, ac)
         await pool.delete(user, ac)

__tests__/sql/index.test.ts

@@ -11,9 +11,14 @@ pub enum DtoType {
     Delete,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Default)]
 pub struct DevupApiOption {
     pub pick: Vec<String>,
     pub omit: Vec<String>,
     pub scope: Vec<String>,
 }
+
+#[derive(Debug, Default)]
+pub struct DevupApiQueryOption {
+    pub query: Vec<String>,
+}

core/api-option/src/lib.rs

@@ -106,40 +106,48 @@ pub fn get_all_proxy_routers() -> Vec<Arc<ProxyRouter>> {
 
 // Schema
 
-static SCHEMA_MAP: Lazy<Mutex<HashMap<String, DevupSchema>>> =
+static SCHEMA_MAP: Lazy<Mutex<HashMap<String, Arc<DevupSchema>>>> =
     Lazy::new(|| Mutex::new(HashMap::new()));
 
 pub fn add_schema(schema: DevupSchema) {
     let mut schema_map = SCHEMA_MAP.lock().unwrap();
-    schema_map.insert(schema.name.clone(), schema);
+    schema_map.insert(schema.name.clone(), Arc::new(schema));
 }
 
-pub fn get_schema(name: &str) -> Option<DevupSchema> {
+pub fn get_schema(name: &str) -> Option<Arc<DevupSchema>> {
     let schema_map = SCHEMA_MAP.lock().unwrap();
-    schema_map.get(name).cloned()
+    schema_map.get(name).map(Arc::clone)
 }
 
-pub fn get_all_schemas() -> Vec<DevupSchema> {
+pub fn get_all_schemas() -> Vec<Arc<DevupSchema>> {
     let schema_map = SCHEMA_MAP.lock().unwrap();
     schema_map.values().cloned().collect()
 }
 
 // Model
 
-static MODEL_MAP: Lazy<Mutex<HashMap<String, model::DevupModel>>> =
+static MODEL_MAP: Lazy<Mutex<HashMap<String, Arc<model::DevupModel>>>> =
     Lazy::new(|| Mutex::new(HashMap::new()));
 
 pub fn add_model(model: model::DevupModel) {
     let mut model_map = MODEL_MAP.lock().unwrap();
-    model_map.insert(model.name.clone(), model);
+    model_map.insert(model.name.clone(), Arc::new(model));
 }
 
-pub fn get_model(name: &str) -> Option<model::DevupModel> {
+pub fn get_model(name: &str) -> Option<Arc<model::DevupModel>> {
     let model_map = MODEL_MAP.lock().unwrap();
     model_map.get(name).cloned()
 }
 
-pub fn get_all_models() -> Vec<model::DevupModel> {
+pub fn get_all_models() -> Vec<Arc<model::DevupModel>> {
     let model_map = MODEL_MAP.lock().unwrap();
     model_map.values().cloned().collect()
 }
+
+pub fn get_model_storage() -> HashMap<String, Arc<model::DevupModel>> {
+    let model_map = MODEL_MAP.lock().unwrap();
+    model_map
+        .iter()
+        .map(|(name, model)| (name.clone(), Arc::clone(model)))
+        .collect()
+}

core/api/src/lib.rs

@@ -10,6 +10,12 @@ use serde::{Deserialize, Serialize};
 use shared_memory::*;
 use std::process;
 
+#[derive(Debug, Copy, Clone)]
+pub enum ObjectFieldNameType {
+    SnakeCase,
+    CamelCase,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, Encode, Decode)]
 pub struct DevupModel {
     pub name: String,
@@ -38,17 +44,18 @@ fn get_shmem_ptr() -> Result<Shmem, ShmemError> {
     shmem.set_owner(false);
     Ok(shmem)
 }
-pub fn add_model(model: DevupModel) -> Result<(), Box<dyn std::error::Error>> {
+pub fn add_model(model: DevupModel) -> Result<Arc<DevupModel>, Box<dyn std::error::Error>> {
     let mut shmem = get_shmem_ptr()?;
 
     let mut data: (HashMap<String, Arc<DevupModel>>, usize) =
         bincode::decode_from_slice(unsafe { shmem.as_slice() }, config::standard())?;
-    data.0.insert(model.name.clone(), Arc::new(model));
+    let n = Arc::new(model);
+    data.0.insert(n.name.clone(), n.clone());
     let serialized = bincode::encode_to_vec(&data, config::standard())?;
     unsafe {
         shmem.as_slice_mut()[0..serialized.len()].copy_from_slice(&serialized);
     };
-    Ok(())
+    Ok(n)
 }
 
 pub fn get_model(name: &str) -> Result<Arc<DevupModel>, Box<dyn std::error::Error>> {

core/model/src/lib.rs

@@ -3,12 +3,8 @@
 /* prettier-ignore */
 module.exports=require('./index')
 class DevupModel{
-    constructor(data){
-        if(data)createModelInstance(this, data)
-    }
-    static create(data){
-        return createModelInstance(new this(), data)
-    }
+constructor(data){if(data)createModelInstance(this, data)}
+static create(data){return createModelInstance(new this(), data)}
 }
 
 module.exports.DevupModel=DevupModel
@@ -26,7 +22,3 @@ function createModelInstance(obj, data){
     }
     return obj
 }
-
-module.exports.createModelInstance=createModelInstance
-
-

libs/node/model/main.js

@@ -8,13 +8,16 @@ pub fn model(env: Env, name: Option<String>) -> Result<JsFunction> {
     let global = ctx.env.get_global()?;
     let reflect: JsObject = global.get_named_property("Reflect")?;
     let get_metadata: JsFunction = reflect.get_named_property("getMetadata")?;
-    let cls: JsObject = ctx.get(0)?;
+    let mut cls: JsObject = ctx.get(0)?;
     let model_name: JsString = cls.get_named_property("name")?;
     let model_name = match name.clone() {
       Some(name) => name,
       None => model_name.into_utf8()?.as_str()?.to_string(),
     };
-
+    cls.set_named_property(
+      "__devup_name",
+      &ctx.env.create_string(model_name.as_str())?.into_unknown(),
+    )?;
     add_model(DevupModel {
       name: model_name.clone(),
       fields: ctx.env.from_js_value(get_metadata.call(

libs/node/model/src/model.rs

@@ -1,6 +1,6 @@
 use napi::{Env, JsFunction, JsObject, JsUnknown, bindgen_prelude::*};
 
-pub fn log(env: &Env, value: JsUnknown) -> Result<()> {
+pub fn log(env: &Env, value: &JsUnknown) -> Result<()> {
   let global = env.get_global()?;
   let console: JsObject = global.get_named_property("console")?;
   let log_fn = console.get_named_property::<JsFunction>("log")?;

libs/node/model/src/utils.rs

@@ -8,3 +8,7 @@ sqlx = { version = "0.8", features = ["postgres", "mysql", "sqlite"] }
 async-trait = "0.1"
 model = { path = "../../../core/model" }
 serde_json = "1.0.140"
+inflections = "1.1.1"
+devup_sql = { path = "../devup_sql" }
+sql_utils = { path = "../sql_utils" }
+api = { path = "../../../core/api" }

sql/core/database_strategy/Cargo.toml

@@ -1,8 +1,12 @@
-use std::sync::Arc;
+use std::{io, sync::Arc};
 
+use api::get_model_storage;
 use async_trait::async_trait;
-use model::{DevupModel, column::DevupModelColumn};
+use devup_sql::generate_find_sql_result;
+use inflections::case::to_snake_case;
+use model::{DevupModel, DevupModelFieldType, ObjectFieldNameType, column::DevupModelColumn};
 use serde_json::{Map, Value};
+use sql_utils::generate_where_sql;
 use sqlx::{Error, MySql, Postgres, Sqlite, Transaction};
 
 pub enum QueryParams {
@@ -86,12 +90,117 @@ pub trait DatabaseStrategy: Send + Sync {
         instance_id: &Map<String, Value>,
         obj: &Value,
         tx: &mut DatabaseTransaction,
-    ) -> Result<SqlResult, Error>;
+    ) -> Result<SqlResult, Error> {
+        let (fields, values): (Vec<_>, Vec<_>) = obj
+            .as_object()
+            .ok_or(Error::Protocol("Wrong object".to_string()))?
+            .into_iter()
+            .filter_map(|(key, value)| {
+                if key.starts_with("__devup_") {
+                    None
+                } else {
+                    Some((to_snake_case(key), value.clone()))
+                }
+            })
+            .unzip();
+        let q = format!(
+            "UPDATE {} SET {} WHERE {}",
+            to_snake_case(&model.name),
+            fields
+                .into_iter()
+                .map(|f| format!("{} = ?", f))
+                .collect::<Vec<String>>()
+                .join(","),
+            generate_where_sql(&Value::Object(instance_id.clone()))?
+        );
+        self.execute(&q, &values, Some(tx))
+            .await
+            .map_err(|e| Error::Protocol(format!("Update Error {} {} {:?}", e, q, values)))?;
+        Ok(SqlResult {
+            instance_id: instance_id.clone(),
+            instance: obj
+                .as_object()
+                .ok_or(Error::Protocol("Wrong object".to_string()))?
+                .clone(),
+        })
+    }
 
     async fn delete_sql(
         &self,
         model: Arc<DevupModel>,
         instance_id: &Map<String, Value>,
         tx: &mut DatabaseTransaction,
-    ) -> Result<(), Error>;
+    ) -> Result<(), Error> {
+        let q = format!(
+            "DELETE FROM {} WHERE {}",
+            to_snake_case(&model.name),
+            generate_where_sql(&Value::Object(instance_id.clone()))?
+        );
+        self.execute(&q, &[], Some(tx))
+            .await
+            .map_err(|e| Error::Protocol(format!("Delete Error {} {} {:?}", e, q, instance_id)))?;
+        Ok(())
+    }
+
+    async fn find(
+        &self,
+        model: &DevupModel,
+        tx: Option<&mut DatabaseTransaction>,
+        field_name_type: ObjectFieldNameType,
+        // option: Option<DevupApiQueryOption>,
+    ) -> Result<Vec<Value>, Error> {
+        let q = generate_find_sql_result(&model, None, &get_model_storage());
+        let s = &q.to_sql(field_name_type);
+        dbg!(s);
+        let result = self.fetch_all(s, &[], tx).await?;
+        Ok(result
+            .into_iter()
+            .map(|v| add_instance_id(model, v, field_name_type))
+            .collect::<Result<Vec<_>, _>>()?)
+    }
+}
+
+pub fn add_instance_id(
+    model: &DevupModel,
+    mut obj: Value,
+    field_name_type: ObjectFieldNameType,
+) -> Result<Value, io::Error> {
+    let _obj = obj
+        .as_object_mut()
+        .ok_or(io::Error::new(io::ErrorKind::InvalidData, "Not an object"))?;
+    // create instance id object
+    let instance_id = {
+        let mut instance_id = Map::new();
+
+        for field in model.fields.iter() {
+            if let DevupModelFieldType::Column(column) = field {
+                if column.primary_key {
+                    instance_id.insert(
+                        match field_name_type {
+                            ObjectFieldNameType::SnakeCase => to_snake_case(&column.name),
+                            // column name is already camel case
+                            ObjectFieldNameType::CamelCase => column.name.clone(),
+                        },
+                        _obj.get(&match field_name_type {
+                            ObjectFieldNameType::SnakeCase => to_snake_case(&column.name),
+                            // column name is already camel case
+                            ObjectFieldNameType::CamelCase => column.name.clone(),
+                        })
+                        .ok_or(io::Error::new(
+                            io::ErrorKind::InvalidData,
+                            "Primary key not found",
+                        ))?
+                        .clone(),
+                    );
+                }
+            }
+        }
+        instance_id
+    };
+
+    _obj.insert(
+        "__devup_instance_id".to_string(),
+        Value::Object(instance_id),
+    );
+    Ok(obj)
 }