crudjt 1.0.0-beta.0

package/package/index.js

@@ -0,0 +1,197 @@
+module.exports = require('./index.node');
+
+const fs = require('fs');
+// const path = require('path');
+const { promisify } = require('util');
+const sleep = promisify(setTimeout);
+
+const os = require('os');
+const path = require('path');
+
+// Визначаємо ОС та архітектуру
+const platform = os.platform(); // 'darwin', 'linux', 'win32'
+const arch = os.arch(); // 'x64', 'arm64', 'ia32', тощо
+
+function copyFileWithCheck(srcPath, destPath) {
+  try {
+    // Перевіряємо існування файлу джерела
+    if (!fs.existsSync(srcPath)) {
+      console.log(`Файл не знайдено: ${srcPath}`);
+      return;
+    }
+
+    // Отримуємо назву файлу та шлях до файлу призначення
+    const fileName = path.basename(srcPath);
+    const destFilePath = path.join(destPath, fileName);
+
+    // Перевіряємо існування файлу призначення
+    if (fs.existsSync(destFilePath)) {
+      // Отримуємо інформацію про файли
+      const srcStats = fs.statSync(srcPath);
+      const destStats = fs.statSync(destFilePath);
+
+      // Якщо назва і розмір збігаються, виходимо з функції
+      if (srcStats.size === destStats.size) {
+        console.log(`Файл вже існує з такою ж назвою та розміром: ${destFilePath}`);
+        return;
+      }
+    }
+
+    // Копіюємо файл
+    if (!fs.existsSync(destPath)) {
+      fs.copyFileSync(sourcePath, targetPath);
+      console.log(`Файл успішно скопійовано в: ${destFilePath}`);
+    }
+
+  } catch (error) {
+    console.error(`Помилка: ${error.message}`);
+  }
+}
+
+///
+// Визначаємо sourcePath
+function getSourcePath() {
+  let archDir;
+  let platformDir;
+
+  // Визначаємо архітектуру
+  switch (arch) {
+    case 'x64':
+      archDir = 'x86_64';
+      break;
+    case 'arm64':
+      archDir = 'arm64';
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+
+  // Визначаємо директорію для платформи
+  switch (platform) {
+    case 'darwin':
+      platformDir = 'macos';
+      break;
+    case 'linux':
+      platformDir = 'linux';
+      break;
+    case 'win32':
+      platformDir = 'windows';
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  // Формуємо шлях до бібліотеки
+  return path.join(__dirname, 'native', platformDir, archDir, 'libstore_jt.dylib');
+}
+
+// Визначаємо targetPath
+function getTargetPath() {
+  let systemLibDir;
+  let libName;
+
+  switch (platform) {
+    case 'darwin':
+      systemLibDir = '/usr/local/lib';
+      libName = 'libstore_jt.dylib';
+      break;
+    case 'linux':
+      systemLibDir = '/usr/lib';
+      libName = 'libstore_jt.so';
+      break;
+    case 'win32':
+      systemLibDir = 'C:\\Windows\\System32';
+      libName = 'libstore_jt.dll';
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  return path.join(systemLibDir, libName);
+}
+///
+
+// const sourcePath = getSourcePath();
+// const targetPath = getTargetPath();
+//
+// copyFileWithCheck(sourcePath, targetPath);
+
+const native = require('.'); // Require the compiled native module
+const msgpack = require('msgpack-lite');
+const { Buffer } = require('buffer');
+const LRUCache = require('./Cache');
+const Validation = require('./Validation');
+
+const lruCache = new LRUCache((value) => native.read(value));
+
+function create(hash, ttl = -1, silence_read = -1) {
+    Validation.validateInsertion(hash, ttl, silence_read);
+
+    // Serialize hash into the format Msgpack
+    const packedData = msgpack.encode(hash);
+
+    // Call native function create, passing it a pointer and the size of the data
+    let token = native.create(packedData, packedData.length, ttl, silence_read);
+    lruCache.insert(token, hash, ttl, silence_read);
+
+    return token;
+}
+
+function read(token) {
+  Validation.validateToken(token);
+
+  let output = lruCache.get(token);
+  if (output) {
+    return output
+  }
+
+  let result_str = native.read(token);
+  if (result_str === "") {
+    return null;
+  }
+
+  let result = JSON.parse(result_str);
+  lruCache.forceInsert(token, result);
+
+  return result;
+}
+
+function update(token, hash, ttl = -1, silence_read = -1) {
+  Validation.validateToken(token);
+  Validation.validateInsertion(hash, ttl, silence_read);
+
+  // Serialize hash into the format Msgpack
+  const packedData = msgpack.encode(hash);
+
+  // Call native function update, passing it a pointer and the size of the data
+  let result = native.update(token, packedData, packedData.length, ttl, silence_read);
+  if (result) {
+    lruCache.insert(token, hash, ttl, silence_read)
+  }
+
+  return result;
+}
+
+function __delete(token) {
+  Validation.validateToken(token);
+
+  lruCache.delete(token);
+
+  return native.delete(token);
+}
+
+// native.encrypted_key("414243");
+// let token = create({qwe: 124});
+// read(token);
+// update(token, {sadsad: 324});
+// __delete(token);
+
+const CRUD_JT = {
+    create,
+    read,
+    update,
+    delete: __delete,
+    encrypted_key: native.encrypted_key
+};
+
+module.exports = CRUD_JT;

package/package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "crud_jt",
+  "version": "0.1.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "cargo test",
+    "cargo-build": "cargo build --message-format=json-render-diagnostics > cargo.log",
+    "cross-build": "cross build --message-format=json-render-diagnostics > cross.log",
+    "postcargo-build": "neon dist < cargo.log",
+    "postcross-build": "neon dist -m /target < cross.log",
+    "debug": "npm run cargo-build --",
+    "build": "npm run cargo-build -- --release",
+    "cross": "npm run cross-build -- --release"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@neon-rs/cli": "0.1.73"
+  },
+  "dependencies": {
+    "lru-cache": "^11.0.1",
+    "msgpack-lite": "^0.1.26",
+    "neon-cli": "^0.10.1"
+  }
+}

package/package/src/lib.rs

@@ -0,0 +1,190 @@
+use std::ffi::CString;
+use core::ffi::CStr;
+use std::os::raw::{c_char, c_int};
+use neon::prelude::*;
+use neon::types::buffer::TypedArray;
+use std::ptr;
+
+///
+use libloading::{Library, Symbol};
+use std::sync::{Mutex, Once};
+use lazy_static::lazy_static;
+use std::sync::Arc;
+
+use std::path::{Path, PathBuf};
+
+fn get_library_path() -> PathBuf {
+    let project_root = Path::new(env!("CARGO_MANIFEST_DIR"));
+
+    let library_subpath = {
+        #[cfg(target_os = "linux")]
+        {
+            if cfg!(target_arch = "x86_64") {
+                "native/linux/store_jt_x86_64.so"
+            } else if cfg!(target_arch = "aarch64") {
+                "native/linux/store_jt_arm64.so"
+            } else {
+                panic!("Unsupported architecture for Linux");
+            }
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            if cfg!(target_arch = "x86_64") {
+                "native/macos/store_jt_x86_64.dylib"
+            } else if cfg!(target_arch = "aarch64") {
+                "native/macos/store_jt_arm64.dylib"
+            } else {
+                panic!("Unsupported architecture for macOS");
+            }
+        }
+
+        #[cfg(target_os = "windows")]
+        {
+            if cfg!(target_arch = "x86_64") {
+                "native/windows/store_jt_x86_64.dll"
+            } else if cfg!(target_arch = "aarch64") {
+                "native/windows/store_jt_arm64.dll"
+            } else {
+                panic!("Unsupported architecture for Windows");
+            }
+        }
+
+        #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+        {
+            panic!("Unsupported OS");
+        }
+    };
+
+    project_root.join(library_subpath)
+}
+
+lazy_static! {
+    pub static ref LIB: Library = {
+        unsafe { Library::new(get_library_path()).expect("Failed to load library") }
+    };
+}
+
+fn _encrypted_key(key: *const c_char) -> Result<u32, Box<dyn std::error::Error>> {
+    unsafe {
+        let func: libloading::Symbol<unsafe extern fn(*const c_char) -> u32> = LIB.get(b"encrypted_key")?;
+        Ok(func(key))
+    }
+}
+
+fn _create(data: *const u8, len: usize, ttl: i64, silence_read: i32) -> Result<*const c_char, Box<dyn std::error::Error>> {
+    unsafe {
+        let func: libloading::Symbol<unsafe extern fn(*const u8, usize, i64, i32) -> *const c_char> = LIB.get(b"__create")?;
+        Ok(func(data, len, ttl, silence_read))
+    }
+}
+
+fn _read(token: *const c_char) -> Result<*const c_char, Box<dyn std::error::Error>> {
+    unsafe {
+        let func: libloading::Symbol<unsafe extern fn(*const c_char) -> *const c_char> = LIB.get(b"__read")?;
+        Ok(func(token))
+    }
+}
+
+fn _update(token: *const c_char, data: *const u8, len: usize, ttl: i64, silence_read: i32) -> Result<*const c_int, Box<dyn std::error::Error>> {
+    unsafe {
+        let func: libloading::Symbol<unsafe extern fn(*const c_char, *const u8, usize, i64, i32) -> *const c_int> = LIB.get(b"__update")?;
+        Ok(func(token, data, len, ttl, silence_read))
+    }
+}
+
+fn _delete(token: *const c_char) -> Result<*const c_int, Box<dyn std::error::Error>> {
+    unsafe {
+        let func: libloading::Symbol<unsafe extern fn(*const c_char) -> *const c_int> = LIB.get(b"__delete")?;
+        Ok(func(token))
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+fn call_encrypted_key(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let key = cx.argument::<JsString>(0)?.value(&mut cx);
+    let c_key = CString::new(key).expect("Failed to create CString");
+
+    _encrypted_key(c_key.as_ptr()).unwrap();
+    Ok(cx.undefined())
+}
+
+fn call_create(mut cx: FunctionContext) -> JsResult<JsString> {
+    let js_buffer = cx.argument::<JsBuffer>(0)?;
+    let data_size = cx.argument::<JsNumber>(1)?;
+    let data_usize = data_size.value(&mut cx) as usize;
+
+    let ttl = cx.argument::<JsNumber>(2)?;
+    let silence_read = cx.argument::<JsNumber>(3)?;
+
+    let ttl_int = ttl.value(&mut cx) as i64;
+    let silence_read_int = silence_read.value(&mut cx) as i32;
+
+    let data = js_buffer.as_slice(&cx);
+    let data_ptr: *const u8 = data.as_ptr();
+
+    let result_ptr = _create(data_ptr, data_usize, ttl_int, silence_read_int).unwrap();
+
+    unsafe {
+        let result_str = CStr::from_ptr(result_ptr).to_string_lossy().into_owned();
+
+        Ok(cx.string(result_str))
+    }
+}
+
+fn call_read(mut cx: FunctionContext) -> JsResult<JsString> {
+    let token = cx.argument::<JsString>(0)?.value(&mut cx);
+    let c_token = CString::new(token).expect("Failed to create CString");
+
+    unsafe {
+        let result = _read(c_token.as_ptr()).unwrap();
+        let result_str = CStr::from_ptr(result).to_string_lossy().into_owned();
+
+        Ok(cx.string(result_str))
+    }
+}
+
+fn call_update(mut cx: FunctionContext) -> JsResult<JsBoolean> {
+    let token = cx.argument::<JsString>(0)?.value(&mut cx);
+    let c_token = CString::new(token).expect("Failed to create CString");
+
+    let js_buffer = cx.argument::<JsBuffer>(1)?;
+    let data_size = cx.argument::<JsNumber>(2)?;
+    let data_usize = data_size.value(&mut cx) as usize;
+
+    let ttl = cx.argument::<JsNumber>(3)?;
+    let silence_read = cx.argument::<JsNumber>(4)?;
+
+    let ttl_int = ttl.value(&mut cx) as i64;
+    let silence_read_int = silence_read.value(&mut cx) as i32;
+
+    let data = js_buffer.as_slice(&cx);
+    let data_ptr: *const u8 = data.as_ptr();
+
+    let output: *const c_int = _update(c_token.as_ptr(), data_ptr, data_usize, ttl_int, silence_read_int).unwrap();
+    let bool: bool = output as usize == 1;
+
+    Ok(cx.boolean(bool))
+}
+
+fn call_delete(mut cx: FunctionContext) -> JsResult<JsBoolean> {
+    let token = cx.argument::<JsString>(0)?.value(&mut cx);
+    let c_token = CString::new(token).expect("Failed to create CString");
+
+    let output: *const c_int = _delete(c_token.as_ptr()).unwrap();
+    let bool: bool = output as usize == 1;
+
+    Ok(cx.boolean(bool))
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    cx.export_function("encrypted_key", call_encrypted_key)?;
+    cx.export_function("create", call_create)?;
+    cx.export_function("read", call_read)?;
+    cx.export_function("update", call_update)?;
+    cx.export_function("delete", call_delete)?;
+
+    Ok(())
+}