jsql-neo 3.5.2 → 4.0.0

package/nativesrc/jsql-neo-native/src/lib.rs

@@ -0,0 +1,281 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use jsql_neo_core::engine::{Engine, HybridEngine, FieldValue, RowStore};
+use jsql_neo_core::types::{FieldSchema, TableDefinition, schema_order_preserving};
+use napi_derive::napi;
+use napi::JsBuffer;
+
+thread_local! {
+    static ENGINE: RefCell<HybridEngine> = RefCell::new(HybridEngine::new());
+}
+
+fn safe_json_result(result: Result<String, String>) -> String {
+    match result {
+        Ok(s) => s,
+        Err(e) => format!(r#"{{"error":"{}"}}"#, e.replace('"', r#"\""#)),
+    }
+}
+
+#[napi]
+pub fn jsql_open(dir: String, mode: String) -> String {
+    ENGINE.with(|eng| {
+        let open_res = eng.borrow_mut().open(&dir, &mode);
+        match open_res {
+            Ok(()) => {
+                let names = eng.borrow().list_tables();
+                let mut out = serde_json::Map::new();
+                out.insert("ok".into(), serde_json::Value::Bool(true));
+                out.insert("tables".into(), serde_json::Value::Array(
+                    names.iter().map(|n| serde_json::Value::String(n.clone())).collect()
+                ));
+                let mut schemas = serde_json::Map::new();
+                for n in &names {
+                    let s = {
+                        let eng_ref = eng.borrow();
+                        eng_ref.table_schema(n)
+                    };
+                    if let Some(s) = s {
+                        let mut v = serde_json::Map::new();
+                        for (k, fs) in &s {
+                            if let Ok(fv) = serde_json::to_value(fs) {
+                                v.insert(k.clone(), fv);
+                            }
+                        }
+                        schemas.insert(n.clone(), serde_json::Value::Object(v));
+                    }
+                }
+                out.insert("schemas".into(), serde_json::Value::Object(schemas));
+                serde_json::to_string(&out).unwrap_or_else(|_| r#"{"ok":true}"#.to_string())
+            }
+            Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e.replace('"', r#"\""#)),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_flush_dirty() -> String {
+    ENGINE.with(|eng| {
+        match eng.borrow().flush_dirty() {
+            Ok(n) => format!(r#"{{"ok":true,"flushed":{}}}"#, n),
+            Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e.replace('"', r#"\""#)),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_evict() -> String {
+    ENGINE.with(|eng| {
+        match eng.borrow().evict_one() {
+            Some(name) => format!(r#"{{"ok":true,"evicted":"{}","remaining":{}}}"#, name, eng.borrow().mem_count()),
+            None => r#"{"ok":true,"evicted":null,"remaining":0}"#.to_string(),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_close() -> String {
+    ENGINE.with(|eng| {
+        eng.borrow_mut().close();
+        r#"{"ok":true}"#.to_string()
+    })
+}
+
+#[napi]
+pub fn jsql_create_table(name: String, schema_json: String) -> String {
+    use schema_order_preserving;
+    let mut d = serde_json::Deserializer::from_str(&schema_json);
+    let schema: Vec<(String, FieldSchema)> = match schema_order_preserving::deserialize(&mut d) {
+        Ok(s) => s,
+        Err(e) => return format!(r#"{{"ok":false,"error":"invalid schema: {}"}}"#, e),
+    };
+    let def = TableDefinition { name: name.clone(), schema };
+    ENGINE.with(|eng| match eng.borrow_mut().create_table(def) {
+        Ok(()) => r#"{"ok":true}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[napi]
+pub fn jsql_drop_table(name: String) -> String {
+    ENGINE.with(|eng| match eng.borrow_mut().drop_table(&name) {
+        Ok(()) => r#"{"ok":true}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[napi]
+pub fn jsql_insert(table: String, data_json: String) -> String {
+    ENGINE.with(|eng| {
+        let data: Vec<HashMap<String, serde_json::Value>> = match serde_json::from_str(&data_json) {
+            Ok(d) => d,
+            Err(e) => return format!(r#"{{"error":"invalid data: {}"}}"#, e),
+        };
+        match eng.borrow_mut().insert(&table, data) {
+            Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
+            Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+        }
+    })
+}
+
+#[inline(always)]
+unsafe fn parse_field_value_unsafe(data: &[u8], off: &mut usize) -> FieldValue {
+    let tag = *data.get_unchecked(*off); *off += 1;
+    match tag {
+        0 => FieldValue::Null,
+        1 => {
+            let n = i64::from_le_bytes([
+                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
+                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
+                *data.get_unchecked(*off+4), *data.get_unchecked(*off+5),
+                *data.get_unchecked(*off+6), *data.get_unchecked(*off+7),
+            ]);
+            *off += 8;
+            FieldValue::Int(n)
+        }
+        2 => {
+            let n = f64::from_le_bytes([
+                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
+                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
+                *data.get_unchecked(*off+4), *data.get_unchecked(*off+5),
+                *data.get_unchecked(*off+6), *data.get_unchecked(*off+7),
+            ]);
+            *off += 8;
+            FieldValue::Float(n)
+        }
+        3 => {
+            let len = u32::from_le_bytes([
+                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
+                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
+            ]) as usize;
+            *off += 4;
+            let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts(
+                data.as_ptr().add(*off), len
+            ));
+            *off += len;
+            FieldValue::String(s.to_string())
+        }
+        4 => { let b = *data.get_unchecked(*off) != 0; *off += 1; FieldValue::Bool(b) }
+        5 => {
+            let n = i32::from_le_bytes([
+                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
+                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
+            ]) as i64;
+            *off += 4;
+            FieldValue::Int(n)
+        }
+        _ => FieldValue::Null,
+    }
+}
+
+#[napi]
+pub fn jsql_insert_buf(table: String, data: JsBuffer) -> String {
+    let buf_val = match data.into_value() {
+        Ok(v) => v,
+        Err(_) => return r#"{"error":"invalid buffer"}"#.to_string(),
+    };
+    ENGINE.with(|eng| {
+        let buf: &[u8] = buf_val.as_ref();
+        let res = eng.borrow().insert_buf(&table, buf)
+            .map(|ids| serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()));
+        safe_json_result(res.map_err(|e| e))
+    })
+}
+
+#[napi]
+pub fn jsql_find(table: String, filter_json: String, limit: i32, offset: i32) -> String {
+    ENGINE.with(|eng| {
+        let filter: Option<HashMap<String, serde_json::Value>> =
+            if filter_json.is_empty() { None } else { serde_json::from_str(&filter_json).ok() };
+        match eng.borrow().find(&table, &filter, Some(limit as usize), Some(offset as usize), None, &None, &None) {
+            Ok((rows, _, _)) => serde_json::to_string(&rows).unwrap_or_else(|_| "[]".to_string()),
+            Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_find_by_id(table: String, id: i64) -> String {
+    ENGINE.with(|eng| {
+        match eng.borrow().find_by_id_json(&table, id as u64) {
+            Ok(Some(s)) => s,
+            Ok(None) => "null".to_string(),
+            Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+        }
+    })
+}
+
+
+
+#[napi]
+pub fn jsql_count(table: String) -> String {
+    ENGINE.with(|eng| match eng.borrow().count(&table) {
+        Ok(c) => format!("{}", c),
+        Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+    })
+}
+
+#[napi]
+pub fn jsql_update_by_id(table: String, id: i64, data_json: String) -> String {
+    ENGINE.with(|eng| {
+        let data: HashMap<String, serde_json::Value> = match serde_json::from_str(&data_json) {
+            Ok(d) => d,
+            Err(e) => return format!(r#"{{"ok":false,"error":"invalid data: {}"}}"#, e),
+        };
+        match eng.borrow_mut().update_by_id(&table, id as u64, data) {
+            Ok(true) => r#"{"ok":true}"#.to_string(),
+            Ok(false) => r#"{"ok":false,"error":"not found"}"#.to_string(),
+            Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_remove_by_id(table: String, id: i64) -> String {
+    ENGINE.with(|eng| match eng.borrow_mut().remove_by_id(&table, id as u64) {
+        Ok(true) => r#"{"ok":true}"#.to_string(),
+        Ok(false) => r#"{"ok":false,"error":"not found"}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[napi]
+pub fn jsql_remove_by_ids(table: String, ids_json: String) -> String {
+    ENGINE.with(|eng| {
+        let ids: Vec<u64> = match serde_json::from_str(&ids_json) {
+            Ok(v) => v,
+            Err(e) => return format!(r#"{{"error":"invalid ids: {}"}}"#, e),
+        };
+        match eng.borrow_mut().remove_by_ids(&table, &ids) {
+            Ok(n) => format!(r#"{{"ok":true,"count":{}}}"#, n),
+            Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_update_by_ids(table: String, batch_json: String) -> String {
+    ENGINE.with(|eng| {
+        let batch: Vec<(u64, HashMap<String, serde_json::Value>)> = match serde_json::from_str(&batch_json) {
+            Ok(v) => v,
+            Err(e) => return format!(r#"{{"error":"invalid batch: {}"}}"#, e),
+        };
+        match eng.borrow_mut().update_by_ids(&table, batch) {
+            Ok(n) => format!(r#"{{"ok":true,"count":{}}}"#, n),
+            Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+        }
+    })
+}
+
+#[napi]
+pub fn jsql_find_by_ids(table: String, ids_json: String) -> String {
+    ENGINE.with(|eng| {
+        let ids: Vec<u64> = match serde_json::from_str(&ids_json) {
+            Ok(v) => v,
+            Err(e) => return format!(r#"{{"error":"invalid ids: {}"}}"#, e),
+        };
+        match eng.borrow().find_by_ids_json(&table, &ids) {
+            Ok(s) => s,
+            Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+        }
+    })
+}

package/package.json

@@ -1,13 +1,18 @@
 {
     "name": "jsql-neo",
-    "version": "3.5.2",
+    "version": "4.0.0",
     "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
     "main": "index.js",
+    "bin": {
+        "jsql": "./bin/jsql"
+    },
     "files": [
         "index.js",
         "lib/",
         "bin/",
         "wasm/",
+        "native/",
+        "nativesrc/",
         "postinstall.js",
         "README.md",
         "LICENSE"
@@ -32,5 +37,8 @@
     "license": "Apache-2.0",
     "engines": {
         "node": ">=14.0.0"
+    },
+    "dependencies": {
+        "@vexify-org/yaggs": "^8.1.0"
     }
 }

package/wasm/jsql_neo_wasm.d.ts

@@ -11,12 +11,20 @@ export function jsql_find(table: string, filter_json: string, limit: number, off
 
 export function jsql_find_by_id(table: string, id: bigint): string;
 
+export function jsql_find_by_ids(table: string, ids_json: string): string;
+
 export function jsql_insert(table: string, data_json: string): string;
 
 export function jsql_insert_buf(table: string, data: Uint8Array): string;
 
 export function jsql_insert_buf_count(table: string, data: Uint8Array): string;
 
+export function jsql_insert_json(table: string, json: string): string;
+
 export function jsql_remove_by_id(table: string, id: bigint): string;
 
+export function jsql_remove_by_ids(table: string, ids_json: string): string;
+
 export function jsql_update_by_id(table: string, id: bigint, data_json: string): string;
+
+export function jsql_update_by_ids(table: string, batch_json: string): string;