memory-sri 1.2.8 → 1.3.1

package/README.md

@@ -1,6 +1,6 @@
 # Memory Library
 
-A simple and customizable memory data utility for Node.js.
+Powerful yet simple memory and queue manager for building efficient Node.js apps.
 
 ## Installation
 
@@ -10,7 +10,7 @@ You can install this package using NPM:
 npm install memory-sri
 ```
 
-## import memory-sri
+## Import memory-sri
 ```bash
 import Memory from 'memory-sri';
 ```
@@ -19,6 +19,28 @@ import Memory from 'memory-sri';
 ```bash
 const Memory = require('memory-sri');
 ```
+## 🛠 API Reference
+#### Memory store
+```bash
+Memory.set(key, value, ttlSeconds?)
+Memory.get(key)
+Memory.ttl(key)
+Memory.del(key)
+Memory.multiple()
+Memory.delall()
+```
+
+#### Task queue
+```bash
+Memory.process(name, fn) → Register a processor for a task type
+Memory.addtask(name, data, retries?) → Enqueue a job
+Memory.runtask(name) → Manually run a queued job
+```
+## ⚠️ Notes
+```bash
+This is in-memory only (no persistence). Data clears when the process restarts.
+Use in production only for lightweight or temporary jobs.
+```
 
 ## Example of Full Usage:
 ### function has three parameters: Identifier, Data, Expire
@@ -42,26 +64,26 @@ Memory.set('5', "not set expire");
 #### set
 ```bash
 // for set it take job to stored data
-Memory.set('1', "a1", 10);
-Memory.set('2', { b: 2 }, 20);
-Memory.set('3', [ "a1", "a2" ], 30);
-Memory.set('4', [ { a: "a1", b: "b1" } ], 40);
+Memory.set(1, 'a1', 20);
+Memory.set(2, { b: 2 }, 30);
+Memory.set(3, [2, 3], 40);
+Memory.set(4, [{ a: 'a1', b: 'b1' }], 50);
 Memory.set('5', "not set expire");
 ```
 
 #### get
 ```bash
 // for get data realtime
-let get1 = Memory.get(1); // "a1"
+let get1 = Memory.get(1); // 'a1'
 let get2 = Memory.get(2); // { b: 2 }
-let get3 = Memory.get(3); // [ "a1", "a2" ]
-let get4 = Memory.get(4); // [ { a: "a1", b: "b1" } ]
+let get3 = Memory.get(3); // [ 2, 3 ]
+let get4 = Memory.get(4); // [ { a: 'a1', b: 'b1' } ]
 ```
 
 #### get timeout
 ```bash
 // for get timeout data realtime
-let ttl1 = Memory.ttl(1); // 10000
+let ttl1 = Memory.ttl(1); // 20000
 ```
 
 #### multiple
@@ -73,10 +95,11 @@ let getall = Memory.multiple();
 ### Output:
 ```bash
 [
-  { id: "1", data: "a1" },
-  { id: "2", data: { b: 2 } },
-  { id: "3", data: [ "a1", "a2" ] },
-  { id: "4", data: [ { a: "a1", b: "b1" } ] }
+  { id: '1', data: 'a1' },
+  { id: '2', data: { b: 2 } },
+  { id: '3', data: [ 2, 3 ] },
+  { id: '4', data: [ { a: 'a1', b: 'b1' } ] }
+  { id: '5', data: 'not set expire' }
 ]
 ```
 
@@ -102,47 +125,112 @@ const plus = function (a, b) {
   return a + b;
 };
 
-Memory.process('test', async function () {
-  console.log(this.data);
-  let get3 = Memory.get('3'); // [ 2, 3 ]
-  let getttl5 = Memory.ttl('5');
-  Memory.del('1');
-  let a = get3[0];
-  let b = get3[1];
+// register processor
+Memory.process('test', async function (data, meta) {
+  console.log("Running queued task with:");
+  console.log(data);
+  console.log(meta);
+  // do your background work
+  let a = data.price;
+  let b = data.value;
   let c = plus(a, b);
-  console.log(`result: ${c}`);
-  let getall = Memory.multiple();
-  console.log(getall);
-  let deleted = Memory.delall();
-  return c;
+  console.log(`total: ${c}`);
 });
+```
 
+
+#### Task usage
+```bash
+// import queue to index.js or app.js for side effects
+const queue = require('./queue.service');
 ```
 
 #### Task usage
 ```bash
 // index.js
 import express from 'express';
-require('./queue.service');
+
+// import queue for side effects
+const queue = require('./queue.service');
+
+// import Memory for in-memory data storage
 const Memory = require('memory-sri');
 
 const app = express();
 app.use(express.json());
 
-// Retrieve Data from Redis
-app.get('/', async (req, res) => {
+// Example route to demonstrate Memory usage
+app.get('/memory', async (req, res) => {
+  try {
+    // set key with TTL (seconds)
+    Memory.set(1, 'a1', 20);
+    Memory.set(2, { b: 2 }, 30);
+    Memory.set(3, [2, 3], 40);
+    Memory.set(4, [{ a: 'a1', b: 'b1' }], 50);
+
+    // set key with no expiry
+    Memory.set(5, 'not set expire');
+
+    // get value
+    console.log(Memory.get(5)); // { b: 2 }
+
+    // check TTL
+    console.log(Memory.ttl(5)); // remaining seconds
+
+    // get all keys
+    let getAll = await Memory.multiple();
+
+    let result = [];
+    for (let i = 0; i < getAll.length; i++) {
+      let key = i + 1;
+      let ttl = Memory.ttl(key);
+      result.push({ id: getAll[i].id, data: getAll[i].data, ttl: ttl });
+    }
+
+    // delete a key
+    Memory.del(1);
+
+    // delete all keys
+    Memory.delall();
+
+    res.json({ data: result });
+  } catch (error) {
+    console.error('Retrieve Error:', error);
+    res.status(500).json({ message: 'Internal Server Error' });
+  }
+});
+
+// Example route to demonstrate Memory usage
+app.get('/run', async (req, res) => {
   try {
-    Memory.set('1', 'a1', 10);
-    Memory.set('2', { b: 2 }, 20);
-    Memory.set('3', [2, 3], 30);
-    Memory.set('4', [{ a: 'a1', b: 'b1' }], 40);
-    Memory.set('5', 'not set expire');
-
-    // "test" is name of task same process
-    // { user: 1 } is data send to task
-    // retry 3 time, maximum 5 time
-    let result = Memory.addtask('test', { user: 1 }, 3);
-    res.json({ id: result.id, value: result.data });
+    // run the task processor
+    let testFunction = function (a, b) {
+      console.log(`result from task function: ${a + b}`);
+      return a + b;
+    };
+
+    // run task with arguments
+    let result = await Memory.runtask(testFunction, [2, 4]);
+
+    res.json({ id: result.id });
+  } catch (error) {
+    console.error('Retrieve Error:', error);
+    res.status(500).json({ message: 'Internal Server Error' });
+  }
+});
+
+// Example route to demonstrate Memory usage
+app.get('/queue', async (req, res) => {
+  try {
+    let dataQueue = {
+      user: 1,
+      value: Math.random(),
+      price: Math.random() * 100,
+    };
+    // enqueue a job
+    let result = Memory.addtask('test', dataQueue, 3);
+
+    res.json({ id: result.id, data: result.data });
   } catch (error) {
     console.error('Retrieve Error:', error);
     res.status(500).json({ message: 'Internal Server Error' });
@@ -154,7 +242,6 @@ const PORT = 3000;
 app.listen(PORT, () => {
   console.log(`Server running on http://localhost:${PORT}`);
 });
-
 ```
 
 ### Key Features:

package/index.d.ts

@@ -6,3 +6,4 @@ export function del(identifier: string): any;
 export function delall(): any;
 export function process(name?: any, taskFn?: any): any;
 export function addtask(name?: any, data?: any, retries?: any): any;
+export function runtask(name?: any, taskFn?: any): any;

package/lib/main.js

@@ -12,7 +12,7 @@ let memory = module.exports;
 /**
  * version
  */
-memory.version = "1.2.8";
+memory.version = "1.3.1";
 
 /**
  * Memory
@@ -41,17 +41,17 @@ memory.multiple = function getDataAll() {
 memory.set = function setData(identifier, data = [], time = 259200) {
   const MAX_TTL = 604800;
   const limittime = Math.min(time, MAX_TTL);
-  return Task.addTaskBE(setTask(identifier, data, limittime), data);
+  return Task.addTaskBE(setTask(identifier, data, limittime), data, 0);
 };
 
 memory.del = function delData(
   identifier = "a501cf48-9e8a-497e-a158-f87081503425"
 ) {
-  return Task.addTaskBE(delTask(identifier), identifier);
+  return Task.addTaskBE(delTask(identifier), identifier, 0);
 };
 
 memory.delall = function delAllData() {
-  return Task.addTaskBE(delAllTask(), "Delete All");
+  return Task.addTaskBE(delAllTask(), "Delete All", 0);
 };
 
 /**
@@ -64,6 +64,15 @@ memory.delall = function delAllData() {
 
 memory.addtask = Task.addTask;
 memory.process = Task.process;
+memory.runtask = function addTaskWorker(taskFn, args = []) {
+  if (Array.isArray(args)) {
+    return Task.addTaskBE(() => taskFn(...args), args, 1000);
+  } else if (args !== undefined && args !== null) {
+    return Task.addTaskBE(() => taskFn(args), args, 1000);
+  } else {
+    return "No arguments provided for the task";
+  }
+};
 
 /**
  * private util functions

package/lib/worker.js

@@ -32,14 +32,16 @@ Task.addTask = function (name = "temp", data = {}, retries = 1) {
   return { id: task.id, data: data };
 };
 
-Task.addTaskBE = function addTaskService(taskFn, data) {
+Task.addTaskBE = function addTaskService(taskFn, data, timeout) {
   if (typeof taskFn !== "function") {
     logData(`Task must be a function`);
     return null;
   }
-  taskIdBE += 1;
+  if (timeout !== 0) {
+    taskIdBE += 1;
+  }
   tasksBE.push({ id: taskIdBE, run: taskFn });
-  processTasks();
+  processTasks(timeout);
   return {
     id: taskIdBE,
     data: data,
@@ -65,8 +67,7 @@ async function runTask(name) {
 
   try {
     task.attempts += 1;
-    const result = await fn.call({
-      data: task.data,
+    const result = await fn(task.data, {
       id: task.id,
       name: task.name,
     });
@@ -83,8 +84,10 @@ async function runTask(name) {
   }
 }
 
-async function processTasks() {
-  await new Promise((resolve) => setTimeout(resolve, 1000));
+async function processTasks(timeout) {
+  if (timeout !== 0) {
+    await new Promise((resolve) => setTimeout(resolve, timeout));
+  }
   if (tasksBE.length === 0) return;
 
   let attempts = 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memory-sri",
-  "version": "1.2.8",
-  "description": "A simple and customizable memory data per 1 loadbalance",
+  "version": "1.3.1",
+  "description": "Powerful yet simple memory and queue manager for building efficient Node.js apps.",
   "scripts": {
     "test": "npx jest ---coverage=false --detectOpenHandles --forceExit",
     "exit": "echo \"No tests specified\" && exit 0",
@@ -16,15 +16,16 @@
     "lib"
   ],
   "keywords": [
-    "temp",
+    "queue",
+    "data-structure",
     "memory",
-    "minimal",
-    "flexible",
-    "node",
-    "utility",
-    "integration"
+    "node"
   ],
   "main": "./index",
   "types": "./index.d.ts",
-  "typings": "./index.d.ts"
+  "typings": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Santipap-Eiamsamlee/memory.git"
+  }
 }