memory-sri 1.2.2 → 1.2.11

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
@@ -41,74 +63,183 @@ Memory.set('5', "not set expire");
 
 #### set
 ```bash
-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);
+// for set it take job to stored data
+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
-let test1 = Memory.get(1); // "a1"
-let test2 = Memory.get(2); // { b: 2 }
-let test3 = Memory.get(3); // [ "a1", "a2" ]
-let test4 = Memory.get(4); // [ { a: "a1", b: "b1" } ]
+// for get data realtime
+let get1 = Memory.get(1); // 'a1'
+let get2 = Memory.get(2); // { b: 2 }
+let get3 = Memory.get(3); // [ 2, 3 ]
+let get4 = Memory.get(4); // [ { a: 'a1', b: 'b1' } ]
 ```
 
 #### get timeout
 ```bash
-let test1 = Memory.ttl(1); // 10000
+// for get timeout data realtime
+let ttl1 = Memory.ttl(1); // 20000
 ```
 
 #### multiple
 ```bash
-let test1 = Memory.multiple();
+// for get data all realtime
+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' }
 ]
 ```
 
 #### delete
 ```bash
+// for delete it take job to delete data from stored
 Memory.del(1);
 ```
 
 #### delete all
 ```bash
+// for delete all it take job to delete all data from stored
 Memory.delall();
 ```
 
 ### Task
-#### Task function
+#### Main page for process
 ```bash
-const plus = function(a, b){
+// queue.service.js
+const Memory = require('memory-sri');
+
+const plus = function (a, b) {
   return a + b;
-}
+};
+
+// register processor
+Memory.process('test', async function () {
+  console.log("Running queued task with:");
+  console.log(this.data);
+  // do your background work
+  let a = this.data.price;
+  let b = this.data.value;
+  let c = plus(a, b);
+  console.log(`total: ${c}`);
+});
 ```
 
+
 #### Task usage
 ```bash
-// "test" is name of task
-// { user: 1 } is data send to task
-// retry 3 time, maximum 5 time
-Task.addtask("test", { user: 1 }, 3);
+// import queue to index.js or app.js for side effects
+const queue = require('./queue.service');
 ```
 
+#### Task usage
 ```bash
-Task.runtask("test", async function () {
-  console.log("Running with data:", this.data);
-  let a = 1;
-  let b = 2;
-  let c = plus(a, b);
-  console.log(`result: ${c}`);
+// index.js
+import express from 'express';
+
+// 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());
+
+// 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 {
+    // 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' });
+  }
+});
+
+// Start Server
+const PORT = 3000;
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
 });
 ```
 

package/index.d.ts

@@ -4,5 +4,6 @@ export function multiple(): any;
 export function set(identifier: string, data?: any, time?: number): any;
 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.1.11";
+memory.version = "1.2.11";
 
 /**
  * Memory
@@ -41,21 +41,21 @@ memory.multiple = function getDataAll() {
 memory.set = function setData(identifier, data = [], time = 259200) {
   const MAX_TTL = 604800;
   const limittime = Math.min(time, MAX_TTL);
-  return Worker.addTask(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 Worker.addTask(delTask(identifier), identifier);
+  return Task.addTaskBE(delTask(identifier), identifier, 0);
 };
 
 memory.delall = function delAllData() {
-  return Worker.addTask(delAllTask(), "Delete All");
+  return Task.addTaskBE(delAllTask(), "Delete All", 0);
 };
 
 /**
- * Worker
+ * Task
  *
  * @param {Fuction} taskFn
  * @param {Object} [args]
@@ -63,7 +63,16 @@ memory.delall = function delAllData() {
  */
 
 memory.addtask = Task.addTask;
-memory.runtask = Task.runTask;
+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

@@ -3,9 +3,16 @@
  */
 let Task = module.exports;
 let tasks = [];
-let isProcessing = false;
 let taskId = 0;
 let registeredFns = {};
+let tasksBE = [];
+let taskIdBE = 0;
+/**
+ * Processor for a task name
+ */
+Task.process = function (name, fn) {
+  registeredFns[name] = fn;
+};
 
 /**
  * Add a job into the queue (before the processor is defined)
@@ -13,7 +20,6 @@ let registeredFns = {};
 Task.addTask = function (name = "temp", data = {}, retries = 1) {
   taskId += 1;
   retries = !retries ? 1 : retries > 5 ? 5 : retries;
-
   const task = {
     id: taskId,
     name,
@@ -21,50 +27,83 @@ Task.addTask = function (name = "temp", data = {}, retries = 1) {
     attempts: 0,
     maxAttempts: retries,
   };
-
   tasks.push(task);
-  processTasks();
-
-  return { id: task.id };
+  runTask(name);
+  return { id: task.id, data: data };
 };
 
-/**
- * Register a processor for a task name
- */
-Task.runTask = function (name, taskFn) {
+Task.addTaskBE = function addTaskService(taskFn, data, timeout) {
   if (typeof taskFn !== "function") {
-    throw new Error("Task must be a function");
+    logData(`Task must be a function`);
+    return null;
   }
-  registeredFns[name] = taskFn;
-  processTasks();
+  if(timeout !== 0){
+    taskIdBE += 1;
+  }
+  tasksBE.push({ id: taskIdBE, run: taskFn });
+  processTasks(timeout);
+  return {
+    id: taskIdBE,
+    data: data,
+  };
 };
 
 /**
  * private util functions
  */
-async function processTasks() {
-  if (isProcessing) return;
-  isProcessing = true;
+async function runTask(name) {
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  const index = tasks.findIndex((t) => t.name === name);
+  /**
+   * no tasks found
+   */
+  if (index === -1) return null;
+  /**
+   * remove from queue
+   */
+  const task = tasks.splice(index, 1)[0];
+  const fn = registeredFns[task.name];
+  if (!fn) throw new Error(`No processor registered for task "${task.name}"`);
 
-  while (tasks.length > 0) {
-    const task = tasks.shift();
-    const fn = registeredFns[task.name];
+  try {
+    task.attempts += 1;
+    const result = await fn.call({
+      data: task.data,
+      id: task.id,
+      name: task.name,
+    });
 
-    if (!fn) {
-      // processor not defined yet → put it back and stop
-      tasks.unshift(task);
-      break;
+    return result;
+  } catch (err) {
+    if (task.attempts < task.maxAttempts) {
+      /**
+       * requeue
+       */
+      tasks.push(task);
     }
+    throw err;
+  }
+}
 
+async function processTasks(timeout) {
+  if (timeout !== 0) {
+    await new Promise((resolve) => setTimeout(resolve, timeout));
+  }
+  if (tasksBE.length === 0) return;
+
+  let attempts = 0;
+  const currentTasks = tasksBE.splice(0, tasksBE.length);
+  for (const taskObj of currentTasks) {
     try {
-      task.attempts += 1;
-      await fn.call({ data: task.data, id: task.id, name: task.name });
+      attempts += 1;
+      await taskObj.run();
     } catch (err) {
-      if (task.attempts < task.maxAttempts) {
-        tasks.push(task);
+      if (attempts < 3) {
+        /**
+         * requeue
+         */
+        await taskObj.run();
       }
     }
   }
-
-  isProcessing = false;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memory-sri",
-  "version": "1.2.2",
-  "description": "A simple and customizable memory data per 1 loadbalance",
+  "version": "1.2.11",
+  "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"
+  }
 }