Implement insert

Author: owjs3901

Cargo.lock

@@ -1,5 +1,7 @@
 import 'reflect-metadata'
 
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs'
+
 import {
   Column,
   DevupModel,
@@ -8,9 +10,13 @@ import {
   Model,
 } from '@devup-api/model'
 import { createSqliteConnection } from '@devup-sql/sqlite'
-describe('sqlite', async () => {
+describe.sequential('sqlite', async () => {
+  if (existsSync('./test.db')) {
+    unlinkSync('./test.db')
+  }
+  writeFileSync('./test.db', '')
   const pool = await createSqliteConnection({
-    url: 'sqlite::memory:',
+    url: 'sqlite:./test.db',
   })
   it.each([
     ['SELECT 1 as value', { value: 1 }],
@@ -74,6 +80,7 @@ describe('sqlite', async () => {
 
       const hasRevision = await pool.hasRevision()
       expect(hasRevision).toBe(false)
+      console.log('hasRevision', hasRevision)
       if (!hasRevision) {
         await pool.setupRevision()
       }
@@ -101,10 +108,36 @@ describe('sqlite', async () => {
         tag: '',
       })
 
-      user.username = 'devup'
-      await user.save()
+      await pool.save(user)
+      expect(await pool.fetchAll('SELECT COUNT(*) as count FROM user')).toEqual(
+        [
+          {
+            count: 1,
+          },
+        ],
+      )
+      const ac = await pool.begin()
+      await pool.save(user, ac)
+
+      expect(await pool.fetchAll('SELECT COUNT(*) as count FROM user')).toEqual(
+        [
+          {
+            count: 1,
+          },
+        ],
+      )
+      await pool.commit(ac)
+
+      expect(await pool.fetchAll('SELECT COUNT(*) as count FROM user')).toEqual(
+        [
+          {
+            count: 2,
+          },
+        ],
+      )
+      // await user.save()
 
-      const user2 = new User()
+      // const user2 = new User()
 
       // const user = await User.findById(1)
       // expect(user?.username).toEqual('devup')

__tests__/sql/index.test.ts

@@ -2,5 +2,35 @@
 /* eslint-disable */
 /* prettier-ignore */
 module.exports=require('./index')
-class DevupModel{}
+class DevupModel{
+    constructor(data){
+        if(data){
+            createModelInstance(this, data)
+        }
+    }
+
+    static create(data){
+        return createModelInstance(new this(), data)
+    }
+}
+
 module.exports.DevupModel=DevupModel
+
+
+function createModelInstance(obj, data){
+    obj.__devup_name = obj.constructor.name
+    if(data){
+        for(const key of Object.keys(data)){
+            let value = data[key]
+            if (value instanceof Date){
+                value = value.toISOString()
+            }
+            obj[key] = value
+        }
+    }
+    return obj
+}
+
+module.exports.createModelInstance=createModelInstance
+
+

libs/node/model/main.js

@@ -4,8 +4,10 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-sqlx = { version = "0.8" }
+sqlx = { version = "0.8", features = ["any"] }
 devup_database_diff = { path = "../devup_database_diff" }
 devup_migrate = { path = "../devup_migrate" }
 model = { path = "../../../core/model" }
 database_strategy = { path = "../database_strategy" }
+serde_json = "1.0.140"
+inflections = "1.1.1"

sql/core/devup_database/Cargo.toml

@@ -1,12 +1,16 @@
 use database_strategy::{DatabaseStrategy, QueryParams};
+
 use devup_migrate::generate_revision_sql::GenerateRevisionActionSqlResult;
 use devup_migrate::get_all_revisions;
 use devup_migrate::revision::DevupSqlRevision;
 use devup_migrate::{
     generate::generate_models_from_revisions, generate_revision_sql::generate_revision_action_sql,
 };
+use inflections::case::to_snake_case;
 use model::{DevupModel, get_all_models};
-use sqlx::query;
+use serde_json::Value;
+use sqlx::any::AnyTransactionManager;
+use sqlx::{AnyConnection, TransactionManager, query};
 use std::time::Duration;
 
 use devup_database_diff::diff_models;
@@ -160,7 +164,7 @@ impl DevupSqlPool {
             .execute(&mut *tx)
             .await?;
 
-            self.commit(tx).await?;
+            self.commit(&mut *tx).await?;
             return Ok(());
         }
 
@@ -224,7 +228,7 @@ impl DevupSqlPool {
         .bind(target_revision)
         .execute(&mut *tx)
         .await?;
-        self.commit(tx).await?;
+        self.commit(&mut *tx).await?;
         Ok(())
     }
 
@@ -244,7 +248,7 @@ impl DevupSqlPool {
             .database_strategy
             .setup_revision(&mut tx)
             .await?;
-        self.commit(tx).await?;
+        self.commit(&mut *tx).await?;
         Ok(())
     }
 
@@ -269,11 +273,66 @@ impl DevupSqlPool {
         }
     }
 
-    pub async fn commit(&self, tx: Transaction<'_, Any>) -> Result<(), Error> {
-        tx.commit().await
+    pub async fn commit(&self, tx: &mut AnyConnection) -> Result<(), Error> {
+        AnyTransactionManager::commit(tx).await?;
+        Ok(())
+    }
+
+    pub async fn rollback(&self, tx: &mut AnyConnection) -> Result<(), Error> {
+        AnyTransactionManager::rollback(tx).await?;
+        Ok(())
     }
 
-    pub async fn rollback(&self, tx: Transaction<'_, Any>) -> Result<(), Error> {
-        tx.rollback().await
+    pub async fn save(&self, obj: &Value, tx: Option<&mut AnyConnection>) -> Result<(), Error> {
+        let table_name = obj
+            .get::<String>("__devup_name".to_string())
+            .ok_or(Error::ColumnNotFound("__devup_name".to_string()))?
+            .as_str()
+            .ok_or(Error::ColumnNotFound("__devup_name".to_string()))?;
+
+        let mut keys = Vec::new();
+        let mut values = Vec::new();
+
+        for (key, value) in obj
+            .as_object()
+            .ok_or(Error::ColumnNotFound("__devup_name".to_string()))?
+            .iter()
+        {
+            if key.starts_with("__devup_") {
+                continue;
+            }
+            if let Some(value) = value.as_str() {
+                keys.push(to_snake_case(key));
+                values.push(value);
+            }
+        }
+
+        let sql = format!(
+            "INSERT INTO {} ({}) VALUES ({})",
+            to_snake_case(table_name),
+            keys.join(", "),
+            values
+                .iter()
+                .enumerate()
+                .map(
+                    |(idx, _)| match self.options.database_strategy.get_query_params() {
+                        QueryParams::Number => format!("${}", idx + 1),
+                        QueryParams::QuestionMark => "?".to_string(),
+                    }
+                )
+                .collect::<Vec<String>>()
+                .join(", ")
+        );
+
+        let mut query = query(&sql);
+        for value in values {
+            query = query.bind(value);
+        }
+        if let Some(tx) = tx {
+            query.execute(&mut *tx).await?;
+        } else {
+            query.execute(self.pool.as_ref().unwrap()).await?;
+        }
+        Ok(())
     }
 }

sql/core/devup_database/src/lib.rs

@@ -11,6 +11,7 @@ serde = { version = "1.0.219", features = ["derive"] }
 tokio = { version = "1.44.2", features = ["fs"] }
 serde_json = "1.0.140"
 database_strategy = { path = "../database_strategy" }
+inflections = "1.1.1"
 
 [dev-dependencies]
 database_strategy_mysql = { path = "../database_strategy_mysql" }

sql/core/devup_migrate/Cargo.toml

@@ -1,4 +1,5 @@
-use database_strategy::{DatabaseStrategy, QueryParams};
+use database_strategy::DatabaseStrategy;
+use inflections::case::to_snake_case;
 use model::column::DevupModelColumnDefault;
 
 use crate::revision::DevupSqlRevisionAction;
@@ -225,20 +226,6 @@ pub fn generate_revision_action_sql(
     GenerateRevisionActionSqlResult { result }
 }
 
-fn to_snake_case(s: &str) -> String {
-    let mut result = String::new();
-    for (i, c) in s.chars().enumerate() {
-        if c.is_uppercase() {
-            if i > 0 {
-                result.push('_');
-            }
-            result.push(c.to_ascii_lowercase());
-        } else {
-            result.push(c);
-        }
-    }
-    result
-}
 #[cfg(test)]
 mod tests {
     use database_strategy_mysql::MysqlDatabaseStrategy;

sql/core/devup_migrate/src/generate_revision_sql.rs

@@ -78,5 +78,8 @@ export declare class DevupNodeSqlPool {
   hasRevision(): Promise<boolean>
   getRevisionSql(revision: number, isUp: boolean): Promise<Array<GenerateRevisionActionSqlWithParams>>
   setupRevision(): Promise<void>
+  commit(tx: DevupNodeSqlTransaction): Promise<void>
+  rollback(tx: DevupNodeSqlTransaction): Promise<void>
+  save(obj: any, tx?: DevupNodeSqlTransaction | undefined | null): Promise<void>
 }
 export declare class DevupNodeSqlTransaction { }