entity-predictor 1.2.2 → 1.3.0

package/README.md

@@ -63,7 +63,8 @@ Output:
 {
   entity: "STATE BANK OF INDIA",
   confidence: 1,
-  confidenceLevel: "Trustable"
+  confidenceLevel: "Trustable",
+  input: "sbi"
 }
 */
 ```
@@ -118,7 +119,31 @@ const predictor = new EntityPredictor(entities, {
 });
 ```
 
-### 6. Add Entities Dynamically
+### 6. Redis Datasets Support
+
+Load entities directly from a Redis source (requires your own redis client).
+
+```javascript
+import Redis from "ioredis"; // or any redis client
+import { EntityPredictor } from "entity-predictor";
+
+const redis = new Redis();
+const predictor = new EntityPredictor(); // Start empty or with some local entities
+
+// Load from a Redis String (JSON)
+// Key content: '["Apple", {"name": "Google", "aliases": ["Alphabet"]}]'
+await predictor.loadFromRedis(redis, { key: "my_entities", type: "json" });
+
+// Load from a Redis Set
+// Key content: SMEMBERS -> ["Tesla", "SpaceX"]
+await predictor.loadFromRedis(redis, { key: "my_set_key", type: "set" });
+
+// Load from a Redis Hash
+// Key content: HGETALL -> { "Amazon": '["AWS"]', "Netflix": "FLIX" }
+await predictor.loadFromRedis(redis, { key: "my_hash_key", type: "hash" });
+```
+
+### 7. Add Entities Dynamically
 
 You can add new entities to an existing predictor instance.
 
@@ -141,7 +166,7 @@ predictor.addEntity("PUNJAB NATIONAL BANK", ["PNB"]);
 
 - `input`: String to search for.
 - `threshold`: (Optional) Minimum confidence score (default `0.6`).
-- **Returns**: Best match object, `{ entity: "UNKNOWN", ... }` if no match found, or `null` if input is invalid.
+- **Returns**: Best match object `{ entity: string, confidence: number, input: string, ... }`, `{ entity: "UNKNOWN", input: string, ... }` if no match found, or `null` if input is invalid.
 
 ### `predictTop(input, limit, threshold)`
 

package/index.d.ts

@@ -13,6 +13,7 @@ export interface PredictionResult {
     entity: string;
     confidence: number;
     confidenceLevel: "Trustable" | "High Confidence" | "Moderate Confidence" | "Low Confidence";
+    input: string;
 }
 
 export class EntityPredictor {
@@ -23,4 +24,9 @@ export class EntityPredictor {
     predictTop(input: string, limit?: number, threshold?: number): PredictionResult[];
 
     addEntity(entity: string | EntityOption): void;
+
+    loadFromRedis(
+        redisClient: any,
+        options: { key: string; type?: "json" | "set" | "hash" }
+    ): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entity-predictor",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Lightweight, Zero Dependency Node.js library for entity name prediction and normalization.",
   "types": "index.d.ts",
   "type": "module",
@@ -23,5 +23,8 @@
     "index.d.ts",
     "package.json"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "ioredis": "^5.8.2"
+  }
 }

package/src/predictor.js

@@ -127,6 +127,7 @@ export class EntityPredictor {
       entity: "UNKNOWN",
       confidence: 0,
       confidenceLevel: "Low Confidence",
+      input,
     };
   }
 
@@ -142,6 +143,10 @@ export class EntityPredictor {
       return [];
     }
 
+    if (this.searchCandidates.length === 0) {
+      return [];
+    }
+
     const normalizedInput = this.normalize(input);
     const matches = findBestMatch(normalizedInput, this.searchCandidates);
 
@@ -151,6 +156,7 @@ export class EntityPredictor {
         entity: this.candidateToEntity[index],
         confidence: Number(rating?.rating?.toFixed(2)),
         confidenceLevel: this._getConfidenceLevel(rating?.rating),
+        input,
       }))
       .filter((m) => m.confidence >= threshold)
       .sort((a, b) => b.confidence - a.confidence);
@@ -176,4 +182,57 @@ export class EntityPredictor {
     if (rating >= 0.6) return "Moderate Confidence";
     return "Low Confidence";
   }
+
+  /**
+   * Loads entities from a Redis source.
+   * @param {Object} redisClient - A Redis client instance (e.g., ioredis or node-redis).
+   * @param {Object} options - Loading options.
+   * @param {string} options.key - The Redis key to fetch.
+   * @param {'json'|'set'|'hash'} [options.type='json'] - The type of data structure in Redis.
+   * @returns {Promise<void>}
+   */
+  async loadFromRedis(redisClient, { key, type = "json" }) {
+    if (!redisClient || typeof redisClient.get !== "function") {
+      throw new TypeError("Invalid Redis client provided.");
+    }
+
+    if (type === "json") {
+      const data = await redisClient.get(key);
+      if (data) {
+        const parsed = JSON.parse(data);
+        if (Array.isArray(parsed)) {
+          parsed.forEach((item) => this.addEntity(item, true));
+        }
+      }
+    } else if (type === "set") {
+      // Assumes simple strings in set
+      if (typeof redisClient.smembers !== "function") {
+        throw new TypeError("Client does not support smembers.");
+      }
+      const members = await redisClient.smembers(key);
+      if (Array.isArray(members)) {
+        members.forEach((member) => this.addEntity(member, true));
+      }
+    } else if (type === "hash") {
+      // Key = Entity Name, Value = JSON string of aliases OR simple string
+      if (typeof redisClient.hgetall !== "function") {
+        throw new TypeError("Client does not support hgetall.");
+      }
+      const hash = await redisClient.hgetall(key);
+      if (hash) {
+        Object.entries(hash).forEach(([name, val]) => {
+          let aliases = [];
+          try {
+            const parsed = JSON.parse(val);
+            if (Array.isArray(parsed)) aliases = parsed;
+            else if (typeof parsed === "string") aliases = [parsed];
+          } catch (e) {
+            // value might be a simple comma-separated string or just raw string
+            aliases = [val];
+          }
+          this.addEntity({ name, aliases }, true);
+        });
+      }
+    }
+  }
 }