entity-predictor 1.2.3 → 1.3.0

package/README.md

@@ -119,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.
 

package/index.d.ts

@@ -24,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.3",
+  "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

@@ -143,6 +143,10 @@ export class EntityPredictor {
       return [];
     }
 
+    if (this.searchCandidates.length === 0) {
+      return [];
+    }
+
     const normalizedInput = this.normalize(input);
     const matches = findBestMatch(normalizedInput, this.searchCandidates);
 
@@ -178,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);
+        });
+      }
+    }
+  }
 }