memory-sri 1.2.2 → 1.2.8

package/README.md

@@ -41,6 +41,7 @@ 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);
@@ -50,20 +51,23 @@ 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); // [ "a1", "a2" ]
+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); // 10000
 ```
 
 #### multiple
 ```bash
-let test1 = Memory.multiple();
+// for get data all realtime
+let getall = Memory.multiple();
 ```
 
 ### Output:
@@ -78,38 +82,79 @@ let test1 = Memory.multiple();
 
 #### 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;
-}
+};
+
+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];
+  let c = plus(a, b);
+  console.log(`result: ${c}`);
+  let getall = Memory.multiple();
+  console.log(getall);
+  let deleted = Memory.delall();
+  return 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);
-```
+// index.js
+import express from 'express';
+require('./queue.service');
+const Memory = require('memory-sri');
 
-```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}`);
+const app = express();
+app.use(express.json());
+
+// Retrieve Data from Redis
+app.get('/', 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 });
+  } 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}`);
+});
+
 ```
 
 ### Key Features:

package/index.d.ts

@@ -4,5 +4,5 @@ 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.8";
 
 /**
  * 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);
 };
 
 memory.del = function delData(
   identifier = "a501cf48-9e8a-497e-a158-f87081503425"
 ) {
-  return Worker.addTask(delTask(identifier), identifier);
+  return Task.addTaskBE(delTask(identifier), identifier);
 };
 
 memory.delall = function delAllData() {
-  return Worker.addTask(delAllTask(), "Delete All");
+  return Task.addTaskBE(delAllTask(), "Delete All");
 };
 
 /**
- * Worker
+ * Task
  *
  * @param {Fuction} taskFn
  * @param {Object} [args]
@@ -63,7 +63,7 @@ memory.delall = function delAllData() {
  */
 
 memory.addtask = Task.addTask;
-memory.runtask = Task.runTask;
+memory.process = Task.process;
 
 /**
  * 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,79 @@ 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) {
   if (typeof taskFn !== "function") {
-    throw new Error("Task must be a function");
+    logData(`Task must be a function`);
+    return null;
   }
-  registeredFns[name] = taskFn;
+  taskIdBE += 1;
+  tasksBE.push({ id: taskIdBE, run: taskFn });
   processTasks();
+  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() {
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  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,6 +1,6 @@
 {
   "name": "memory-sri",
-  "version": "1.2.2",
+  "version": "1.2.8",
   "description": "A simple and customizable memory data per 1 loadbalance",
   "scripts": {
     "test": "npx jest ---coverage=false --detectOpenHandles --forceExit",