memory-sri 1.0.3 → 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Santipap Eiamsamlee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,96 +1,128 @@
-# Memory Library
-
-A simple and customizable memory data utility for Node.js.
-
-## Installation
-
-You can install this package using NPM:
-
-```bash
-npm install memory-sri
-```
-
-## import memory-sri
-```bash
-import Memory from 'memory-sri';
-```
-
-### OR
-```bash
-const Memory = require('memory-sri');
-```
-
-## Example of Full Usage:
-### function has three parameters: Identifier, Data, Expire
-Memory.set('1', "a1", 10); 
-// Key '1', Value "a1", Expires in 10 seconds
-
-Memory.set('2', { b: 2 }, 20); 
-// Key '2', Value is an object, Expires in 20 seconds
-
-Memory.set('3', [ "a1", "a2" ], 30);
-// Key '3', Value is an array of strings, Expires in 30 seconds
-
-Memory.set('4', [ { a: "a1", b: "b1" } ], 40);
-// Key '4', Value is an array of objects, Expires in 40 seconds
-
-Memory.set('5', "not set expire");
-// Data will expire in 12 hours.
-
-
-#### 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);
-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" } ]
-```
-
-#### get timeout
-```bash
-let test1 = Memory.ttl(1); // 10000
-```
-
-#### multiple
-```bash
-let test1 = 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" } ] }
-]
-```
-
-#### delete
-```bash
-Memory.del(1);
-```
-
-#### delete all
-```bash
-Memory.delall();
-```
-
-### Key Features:
-- **Installation**: Instructions on how to install the package with NPM.
-- **Usage**: Detailed steps on how to import and use the `memory-sri` library in your application.
-- **Lightweight In-Memory Storage**: Store strings, objects, arrays, or nested structures with minimal overhead.
-- **Simple function**: Provides set, get, ttl, multiple, del, and delall for easy data handling.
-- **Automatic Expiry Support**: Each key can have an expiration time (TTL) in seconds.
-- **Flexible Data Types**: Supports strings, objects, arrays, and complex nested data.
-- **Batch Retrieval**: multiple() method returns all stored data in a clean array format.
-- **Easy Integration**: Works with both CommonJS (require) and ES Modules (import).
+# Memory Library
+
+A simple and customizable memory data utility for Node.js.
+
+## Installation
+
+You can install this package using NPM:
+
+```bash
+npm install memory-sri
+```
+
+## import memory-sri
+```bash
+import Memory from 'memory-sri';
+```
+
+### OR
+```bash
+const Memory = require('memory-sri');
+```
+
+## Example of Full Usage:
+### function has three parameters: Identifier, Data, Expire
+Memory.set('1', "a1", 10); 
+// Key '1', Value "a1", Expires in 10 seconds
+
+Memory.set('2', { b: 2 }, 20); 
+// Key '2', Value is an object, Expires in 20 seconds
+
+Memory.set('3', [ "a1", "a2" ], 30);
+// Key '3', Value is an array of strings, Expires in 30 seconds
+
+Memory.set('4', [ { a: "a1", b: "b1" } ], 40);
+// Key '4', Value is an array of objects, Expires in 40 seconds
+
+Memory.set('5', "not set expire");
+// If no expiration time is set, the data will automatically expire after 3 days or 259200 seconds.
+// Maximum 7 days or 604800 seconds.
+
+
+#### 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);
+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" } ]
+```
+
+#### get timeout
+```bash
+let test1 = Memory.ttl(1); // 10000
+```
+
+#### multiple
+```bash
+let test1 = 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" } ] }
+]
+```
+
+#### delete
+```bash
+Memory.del(1);
+```
+
+#### delete all
+```bash
+Memory.delall();
+```
+
+### Task
+#### Task function
+```bash
+const plus = function(a, b){
+  return a + b;
+}
+```
+
+#### 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);
+```
+
+```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}`);
+});
+```
+
+### Key Features:
+- **Installation**: Instructions on how to install the package with NPM.
+- **Usage**: Detailed steps on how to import and use the `memory-sri` library in your application.
+- **Lightweight In-Memory Storage**: Store strings, objects, arrays, or nested structures with minimal overhead.
+- **Simple function**: Provides set, get, ttl, multiple, del, and delall for easy data handling.
+- **Automatic Expiry Support**: Each key can have an expiration time (TTL) in seconds.
+- **Flexible Data Types**: Supports strings, objects, arrays, and complex nested data.
+- **Batch Retrieval**: multiple() method returns all stored data in a clean array format.
+- **Easy Integration**: Works with both CommonJS (require) and ES Modules (import).
+
+### New Features:
+- **Background Task Processing**: A separate worker process reads tasks from the queue and runs the function.
+
+- **Test jest**: Jest tests verify core functionality, TTL sorting, and correct task recording.

package/index.d.ts

@@ -0,0 +1,8 @@
+export function get(identifier: string): any;
+export function ttl(identifier: string): any;
+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 addtask(name?: any, data?: any, retries?: any): any;
+export function runtask(name?: any, taskFn?: any): any;

package/index.js

@@ -1,34 +1,17 @@
-const Memory = require("./src/memory");
-
-function getSearch(identifier = "a501cf48-9e8a-497e-a158-f87081503425") {
-  return Memory.get(identifier);
-}
-
-function getDataAll() {
-  return Memory.multiple();
-}
-
-function getTimeout(identifier = "a501cf48-9e8a-497e-a158-f87081503425") {
-  return Memory.ttl(identifier);
-}
-
-function setFormat(identifier, data = [], time = 43200) {
-  Memory.set(identifier, data, time);
-}
-
-function delData(identifier = "a501cf48-9e8a-497e-a158-f87081503425") {
-  return Memory.del(identifier);
-}
-
-function delAll() {
-  return Memory.delall();
-}
-
-module.exports = {
-  set: setFormat,
-  get: getSearch,
-  del: delData,
-  delall: delAll,
-  ttl: getTimeout,
-  multiple: getDataAll,
-};
+const Task = require("./lib/main");
+
+const plus = function (a, b) {
+  return a + b;
+};
+
+Task.addtask("test", { user: 1 }, 3);
+
+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}`);
+});
+
+module.exports = Task;

package/lib/main.js

@@ -0,0 +1,82 @@
+/**
+ * module dependencies
+ */
+const Memory = require("./memory");
+const Task = require("./worker");
+
+/**
+ * expose object
+ */
+let memory = module.exports;
+
+/**
+ * version
+ */
+memory.version = "1.1.11";
+
+/**
+ * Memory
+ *
+ * @param {String} identifier
+ * @param {Number} time
+ * @param {Object} [data]
+ * @api public
+ */
+memory.get = function getSearch(
+  identifier = "a501cf48-9e8a-497e-a158-f87081503425"
+) {
+  return Memory.get(identifier);
+};
+
+memory.ttl = function getTimeout(
+  identifier = "a501cf48-9e8a-497e-a158-f87081503425"
+) {
+  return Memory.ttl(identifier);
+};
+
+memory.multiple = function getDataAll() {
+  return Memory.multiple();
+};
+
+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);
+};
+
+memory.del = function delData(
+  identifier = "a501cf48-9e8a-497e-a158-f87081503425"
+) {
+  return Worker.addTask(delTask(identifier), identifier);
+};
+
+memory.delall = function delAllData() {
+  return Worker.addTask(delAllTask(), "Delete All");
+};
+
+/**
+ * Worker
+ *
+ * @param {Fuction} taskFn
+ * @param {Object} [args]
+ * @api public
+ */
+
+memory.addtask = Task.addTask;
+memory.runtask = Task.runTask;
+
+/**
+ * private util functions
+ */
+
+function setTask(identifier, data, time) {
+  return () => Memory.set(identifier, data, time);
+}
+
+function delTask(identifier) {
+  return () => Memory.del(identifier);
+}
+
+function delAllTask() {
+  return () => Memory.delall();
+}

package/{src → lib}/memory.js

@@ -1,83 +1,96 @@
-const attemptsStore = {};
-
-/* save data */
-function recordAttempt(identifier, data, timeoutSeconds) {
-  const now = Date.now();
-  const expiryTime = now + timeoutSeconds * 1000;
-  const elapsed = expiryTime - now;
-  const entry = { time: expiryTime, data, ttl: elapsed };
-  attemptsStore[identifier] = entry;
-  return entry;
-}
+/**
+ * expose object
+ */
+let Memory = module.exports;
 
-/* validate timeout */
-function getRemainingTime(identifier) {
-  const entry = attemptsStore[identifier];
-  if (!entry) return 0;
-  const now = Date.now();
-  const elapsed = entry.time - now;
-  const entryID = { time: entry.time, data: entry.data, ttl: elapsed };
-  attemptsStore[identifier] = entryID;
-  if (elapsed <= 0) {
-    del(identifier);
-    return 0;
-  }
-  return elapsed;
-}
+const attemptsStore = {};
+let timeoutJob = null;
 
 /* set data and timeout */
-function set(identifier, data, time) {
+Memory.set = function setService(identifier, data, time) {
   recordAttempt(identifier, data, time);
+  running();
   return "created";
-}
+};
 
 /* get data by id */
-function get(identifier) {
+Memory.get = function getService(identifier) {
   const now = Date.now();
   const entry = attemptsStore[identifier];
   if (!entry) return null;
 
   const timeout = entry.time - now;
-  getRemainingTime(identifier);
+  ttlService(identifier);
   if (timeout <= 0) {
-    del(identifier);
     return null;
   }
   return attemptsStore[identifier].data;
-}
+};
 
 /* get all data */
-function multiple() {
+Memory.multiple = function multipleService() {
+  for (const identifier in attemptsStore) {
+    ttlService(identifier);
+  }
   return Object.entries(attemptsStore).map(([id, entry]) => ({
     id,
     data: entry.data,
   }));
-}
-
-/* delete data by id */
-function del(identifier) {
-  delete attemptsStore[identifier];
-  return "deleted";
-}
+};
 
 /* delete all data */
-function delall() {
+Memory.delall = function delallService() {
   Object.keys(attemptsStore).forEach((key) => delete attemptsStore[key]);
   return "deleted";
-}
+};
+
+/* validate timeout */
+Memory.ttl = ttlService;
 
+/* delete data by id */
+Memory.del = delService;
+
+/**
+ * private util functions
+ */
 /* delete data has expire in 15 minutes. */
-setInterval(() => {
+function running() {
+  const now = Date.now();
+  const elapsed = timeoutJob - now;
+  if (elapsed > 0) {
+    return;
+  }
   for (const identifier in attemptsStore) {
-    getRemainingTime(identifier);
+    ttlService(identifier);
   }
-}, 900 * 1000);
+  const expiryTime = now + 900 * 1000;
+  timeoutJob = expiryTime;
+}
 
-module.exports = {
-  set,
-  get,
-  ttl: getRemainingTime,
-  del,
-  multiple,
-  delall,
-};
+function recordAttempt(identifier, data, timeoutSeconds) {
+  const now = Date.now();
+  const expiryTime = now + timeoutSeconds * 1000;
+  const elapsed = expiryTime - now;
+  const entry = { time: expiryTime, data, ttl: elapsed };
+  attemptsStore[identifier] = entry;
+  return entry;
+}
+
+function ttlService(identifier) {
+  const entry = attemptsStore[identifier];
+  if (!entry) return 0;
+  const now = Date.now();
+  const elapsed = entry.time - now;
+  const entryID = { time: entry.time, data: entry.data, ttl: elapsed };
+  attemptsStore[identifier] = entryID;
+  if (elapsed <= 0) {
+    delService(identifier);
+    return 0;
+  }
+  return elapsed;
+}
+
+function delService(identifier) {
+  delete attemptsStore[identifier];
+  return "deleted";
+}

package/lib/worker.js

@@ -0,0 +1,70 @@
+/**
+ * expose object
+ */
+let Task = module.exports;
+let tasks = [];
+let isProcessing = false;
+let taskId = 0;
+let registeredFns = {};
+
+/**
+ * Add a job into the queue (before the processor is defined)
+ */
+Task.addTask = function (name = "temp", data = {}, retries = 1) {
+  taskId += 1;
+  retries = !retries ? 1 : retries > 5 ? 5 : retries;
+
+  const task = {
+    id: taskId,
+    name,
+    data,
+    attempts: 0,
+    maxAttempts: retries,
+  };
+
+  tasks.push(task);
+  processTasks();
+
+  return { id: task.id };
+};
+
+/**
+ * Register a processor for a task name
+ */
+Task.runTask = function (name, taskFn) {
+  if (typeof taskFn !== "function") {
+    throw new Error("Task must be a function");
+  }
+  registeredFns[name] = taskFn;
+  processTasks();
+};
+
+/**
+ * private util functions
+ */
+async function processTasks() {
+  if (isProcessing) return;
+  isProcessing = true;
+
+  while (tasks.length > 0) {
+    const task = tasks.shift();
+    const fn = registeredFns[task.name];
+
+    if (!fn) {
+      // processor not defined yet → put it back and stop
+      tasks.unshift(task);
+      break;
+    }
+
+    try {
+      task.attempts += 1;
+      await fn.call({ data: task.data, id: task.id, name: task.name });
+    } catch (err) {
+      if (task.attempts < task.maxAttempts) {
+        tasks.push(task);
+      }
+    }
+  }
+
+  isProcessing = false;
+}

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "memory-sri",
-  "version": "1.0.3",
-  "description": "A simple and customizable memory data utility for Node.js",
-  "main": "index.js",
+  "version": "1.2.1",
+  "description": "A simple and customizable memory data per 1 loadbalance",
   "scripts": {
-    "test": "echo \"No tests specified\" && exit 0",
+    "test": "npx jest ---coverage=false --detectOpenHandles --forceExit",
+    "exit": "echo \"No tests specified\" && exit 0",
     "dev": "node index.js"
   },
+  "author": "Santipap Eiamsamlee",
+  "license": "MIT",
+  "files": [
+    "README.md",
+    "index.js",
+    "index.d.ts",
+    "lib"
+  ],
   "keywords": [
     "temp",
     "memory",
@@ -16,6 +24,7 @@
     "utility",
     "integration"
   ],
-  "author": "Santipap Eiamsamlee",
-  "license": "MIT"
+  "main": "./index",
+  "types": "./index.d.ts",
+  "typings": "./index.d.ts"
 }