Implement creating table

Author: owjs3901

Cargo.lock

@@ -1,6 +1,12 @@
 import 'reflect-metadata'
 
-import { Column, DevupModel, Func, Model } from '@devup-api/model'
+import {
+  Column,
+  DevupModel,
+  DevupModelColumnType,
+  Func,
+  Model,
+} from '@devup-api/model'
 import { createSqliteConnection } from '@devup-sql/sqlite'
 describe('sqlite', async () => {
   const pool = await createSqliteConnection({
@@ -56,6 +62,7 @@ describe('sqlite', async () => {
           // local default
           default: () => 'Hello',
           nullable: true,
+          type: DevupModelColumnType.Text,
         })
         tag?: string
 
@@ -78,8 +85,8 @@ describe('sqlite', async () => {
       const revisionSql = await pool.getRevisionSql(nextRevision, true)
       expect(revisionSql).toEqual([
         {
-          sql: `CREATE TABLE "User" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "username" TEXT, "tag" TEXT, "createdAt" TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP))`,
-          revision: 1,
+          sql: `CREATE TABLE user (id INTEGER NOT NULL, username VARCHAR(255) NOT NULL DEFAULT \`devup\`, tag TEXT NULL, created_at DATE NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (id))`,
+          params: [],
         },
       ])
       expect(await pool.getCurrentRevision()).toBe(0)

__tests__/sql/index.test.ts

@@ -1,24 +1,23 @@
-import { createPostgresPool } from "@devup-sql/postgres";
+import { createPostgresPool } from '@devup-sql/postgres'
 
 async function main(): Promise<void> {
-    try{
-
+  try {
     console.log('[JS] create pool')
     const pool = await createPostgresPool()
 
     console.log('[JS] execute', pool)
 
-    const result1 = await pool.fetchAll("SELECT 3", [])
+    const result1 = await pool.fetchAll('SELECT 3', [])
     console.info('[JS] result1', result1)
-    const result2 = await pool.fetchAll("SELECT 2", [])
+    const result2 = await pool.fetchAll('SELECT 2', [])
     console.info('[JS] result2', result2)
-    const result = await pool.execute("SELECT 1", [])
+    const result = await pool.execute('SELECT 1', [])
 
     console.info('[JS] result', result)
     console.info('[JS] finish')
-    } catch (error) {
-        console.error('[JS] error', error)
-    }
+  } catch (error) {
+    console.error('[JS] error', error)
+  }
 }
 
 console.log('[JS] start')

apps/sql-demo/src/index.ts

@@ -7,3 +7,4 @@ edition = "2024"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 once_cell = "1.21.3"
+bincode = "2.0.1"

core/api-option/Cargo.toml

@@ -1,6 +1,7 @@
+use bincode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub enum DtoType {
     One,
     List,

core/api-option/src/lib.rs

@@ -9,3 +9,5 @@ serde_json = "1.0.140"
 once_cell = "1.21.3"
 schema = { path = "../schema" }
 api-option = { path = "../api-option" }
+shared_memory = "0.12.4"
+bincode = "2.0.1"

core/model/Cargo.toml

@@ -1,9 +1,10 @@
 use api_option::DtoType;
+use bincode::{Decode, Encode};
 use schema::{DevupSchema, field::DevupSchemaField};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq, Encode, Decode)]
 pub enum DevupModelColumnType {
     String(u32),
     Text,
@@ -32,36 +33,36 @@ pub enum DevupModelColumnType {
     Schema(DevupSchema),
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub enum DevupModelColumnUnique {
     True,
     Key(String),
 }
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub enum DevupModelColumnIndex {
     True,
     Key(String),
 }
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub enum DevupModelColumnDefault {
     Default(String),
     ServerDefault(String),
     Func(String),
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub enum DevupModelColumnDtoOptionType {
     All,
     Each(Vec<DtoType>),
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub struct DevupModelColumnDtoOption {
     pub pick: Option<DevupModelColumnDtoOptionType>,
     pub omit: Option<DevupModelColumnDtoOptionType>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq, Encode, Decode)]
 pub struct DevupModelColumn {
     pub name: String,
     pub r#type: DevupModelColumnType,
@@ -79,14 +80,14 @@ pub struct DevupModelColumn {
     pub dto: Option<DevupModelColumnDtoOption>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default, Encode, Decode)]
 pub struct DevupModelRelation {
     pub name: String,
     pub field: Option<String>,
     pub dto: Option<DevupModelColumnDtoOption>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Encode, Decode)]
 pub enum DevupModelFieldType {
     Column(DevupModelColumn),
     Relation(DevupModelRelation),

core/model/src/column.rs

@@ -6,30 +6,73 @@ use std::{
     sync::{Arc, Mutex},
 };
 
+use bincode::{Decode, Encode, config};
 pub use column::DevupModelFieldType;
+
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
+use shared_memory::*;
+#[derive(Debug, Serialize, Deserialize, Clone, Encode, Decode)]
 pub struct DevupModel {
     pub name: String,
     pub fields: Vec<DevupModelFieldType>,
 }
+// current timestamp
+static INIT: Lazy<Mutex<bool>> = Lazy::new(|| Mutex::new(false));
+
+fn get_shmem_ptr() -> Result<Shmem, ShmemError> {
+    let shmem = match ShmemConf::new()
+        .size(4096)
+        .os_id("devup_model_map")
+        .create()
+    {
+        Ok(m) => m,
+        Err(ShmemError::MappingIdExists | ShmemError::LinkExists) => {
+            ShmemConf::new().os_id("devup_model_map").open().unwrap()
+        }
+        Err(e) => {
+            eprintln!("Unable to create or open shmem file devup_model_map : {e}");
+            return Err(e);
+        }
+    };
+    Ok(shmem)
+}
+pub fn add_model(model: DevupModel) -> Result<(), Box<dyn std::error::Error>> {
+    let mut shmem = get_shmem_ptr()?;
 
-static MODEL_MAP: Lazy<Mutex<HashMap<String, Arc<DevupModel>>>> =
-    Lazy::new(|| Mutex::new(HashMap::new()));
+    let mut init = INIT.lock().unwrap();
 
-pub fn add_model(model: DevupModel) {
-    MODEL_MAP
-        .lock()
-        .unwrap()
-        .insert(model.name.clone(), Arc::new(model));
+    if !*init {
+        *init = true;
+        unsafe {
+            shmem.as_slice_mut()[0..4096].fill(0);
+        }
+    }
+
+    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 serialized = bincode::encode_to_vec(&data, config::standard())?;
+    unsafe {
+        shmem.as_slice_mut()[0..serialized.len()].copy_from_slice(&serialized);
+    };
+
+    Ok(())
 }
 
-pub fn get_model(name: &str) -> Option<Arc<DevupModel>> {
-    MODEL_MAP.lock().unwrap().get(name).cloned()
+pub fn get_model(name: &str) -> Result<Arc<DevupModel>, Box<dyn std::error::Error>> {
+    let shmem = get_shmem_ptr()?;
+    let data: (HashMap<String, Arc<DevupModel>>, usize) =
+        bincode::decode_from_slice(unsafe { shmem.as_slice() }, config::standard())?;
+
+    let model = data.0.get(name).cloned().unwrap();
+
+    Ok(model)
 }
 
-pub fn get_all_models() -> Vec<Arc<DevupModel>> {
-    MODEL_MAP.lock().unwrap().values().cloned().collect()
+pub fn get_all_models() -> Result<Vec<Arc<DevupModel>>, Box<dyn std::error::Error>> {
+    let shmem = get_shmem_ptr()?;
+    let data: (HashMap<String, Arc<DevupModel>>, usize) =
+        bincode::decode_from_slice(unsafe { shmem.as_slice() }, config::standard())?;
+    Ok(data.0.values().cloned().collect())
 }

core/model/src/lib.rs

@@ -7,3 +7,4 @@ edition = "2024"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 once_cell = "1.21.3"
+bincode = "2.0.1"

core/schema/Cargo.toml

@@ -1,7 +1,8 @@
+use bincode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
 pub enum DevupSchemaField {
     String,
     Int,