resplite 1.4.10 → 1.4.14

package/README.md

@@ -578,7 +578,7 @@ To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbe
 | **Sets** | SADD, SREM, SMEMBERS, SISMEMBER, SCARD, SPOP, SRANDMEMBER |
 | **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, LSET, LTRIM, BLPOP, BRPOP |
 | **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANK, ZREVRANK, ZCOUNT, ZINCRBY, ZREMRANGEBYRANK, ZREMRANGEBYSCORE |
-| **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
+| **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.GET, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
 | **Introspection** | TYPE, OBJECT IDLETIME, SCAN, KEYS, RENAME, MONITOR |
 | **Admin** | SQLITE.INFO, CACHE.INFO, MEMORY.INFO |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resplite",
-  "version": "1.4.10",
+  "version": "1.4.14",
   "description": "A RESP2 server with practical Redis compatibility, backed by SQLite",
   "type": "module",
   "main": "src/index.js",

package/spec/09-search-ft-commands.md

@@ -11,6 +11,7 @@ Originally Appendix D. Goals, data model, FT.CREATE/ADD/DEL/SEARCH/SUG* behavior
   * `FT.INFO`
   * `FT.ADD`
   * `FT.DEL`
+  * `FT.GET`
   * `FT.SUGADD`
   * `FT.SUGGET`
   * `FT.SUGDEL`
@@ -254,6 +255,31 @@ RESP Integer:
 
 ---
 
+# D.7.5 FT.GET
+
+Aligned with RediSearch: load a single document by id from the index (not from the Redis keyspace).
+
+## D.7.5.1 Syntax
+
+```
+FT.GET {index} {doc_id}
+```
+
+## D.7.5.2 Behavior
+
+* If the index does not exist: error `Unknown index name`.
+* If the document is not in `search_docs__idx`: RESP **nil** (null bulk).
+* Otherwise: RESP **array** of field names and values, `[field, value, ...]`, in **schema field order** (same field names as `FT.ADD`).
+* Empty string field values are returned as **nil** (same idea as RediSearch’s `HGETALL`-based reply for empty values).
+
+## D.7.5.3 Errors
+
+* Wrong arity / bad tokens: `-ERR syntax error`
+* Invalid index name: `-ERR invalid index name`
+* Index missing: `-Unknown index name`
+
+---
+
 # D.8 FT.SEARCH
 
 ## D.8.1 Required syntax (your example)
@@ -804,6 +830,14 @@ FT.DEL IndexName DocId
 
 Return integer 1/0.
 
+### FT.GET
+
+```
+FT.GET IndexName DocId
+```
+
+Same `DocId` rules as `FT.DEL`. Return: flat array of fields and values, or nil if the document is not indexed.
+
 ### FT.SEARCH
 
 ```

package/src/commands/ft/parser.js

@@ -131,6 +131,22 @@ export function parseFtDel(args) {
   return { indexName, docId };
 }
 
+/**
+ * Parse FT.GET args: IndexName DocId (same doc id rules as FT.DEL)
+ * @param {Buffer[]} args
+ * @returns {{ indexName: string, docId: string } | { error: string }}
+ */
+export function parseFtGet(args) {
+  if (!args || args.length !== 2) return { error: 'ERR syntax error' };
+  expectUtf8(args[0]);
+  expectUtf8(args[1]);
+  const indexName = toStr(args[0]).trim();
+  const docId = toStr(args[1]);
+  if (!INDEX_NAME_RE.test(indexName)) return { error: 'ERR invalid index name' };
+  if (docId.length < 1 || docId.length > 256 || docId.includes('\u0000')) return { error: 'ERR syntax error' };
+  return { indexName, docId };
+}
+
 /**
  * Parse FT.SEARCH args: IndexName Query [NOCONTENT] [LIMIT offset count]
  * @param {Buffer[]} args

package/src/commands/ft-get.js

@@ -0,0 +1,21 @@
+/**
+ * FT.GET index doc_id — return document fields as a flat array [field, value, ...] or nil if missing.
+ * Matches RediSearch: single doc by id; unknown index errors; not indexed returns null.
+ */
+
+import { parseFtGet } from './ft/parser.js';
+import { getDocumentFields } from '../storage/sqlite/search.js';
+
+export function handleFtGet(engine, args) {
+  const db = engine._db;
+  if (!db) return { error: 'ERR SQLite not available' };
+  const parsed = parseFtGet(args);
+  if (parsed.error) return { error: parsed.error };
+  try {
+    const fields = getDocumentFields(db, parsed.indexName, parsed.docId);
+    return fields;
+  } catch (e) {
+    const msg = e?.message ?? String(e);
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/registry.js

@@ -79,6 +79,7 @@ import * as ftCreate from './ft-create.js';
 import * as ftInfo from './ft-info.js';
 import * as ftAdd from './ft-add.js';
 import * as ftDel from './ft-del.js';
+import * as ftGet from './ft-get.js';
 import * as ftSearch from './ft-search.js';
 import * as ftSugadd from './ft-sugadd.js';
 import * as ftSugget from './ft-sugget.js';
@@ -164,6 +165,7 @@ const HANDLERS = new Map([
   ['FT.INFO', (e, a) => ftInfo.handleFtInfo(e, a)],
   ['FT.ADD', (e, a) => ftAdd.handleFtAdd(e, a)],
   ['FT.DEL', (e, a) => ftDel.handleFtDel(e, a)],
+  ['FT.GET', (e, a) => ftGet.handleFtGet(e, a)],
   ['FT.SEARCH', (e, a) => ftSearch.handleFtSearch(e, a)],
   ['FT.SUGADD', (e, a) => ftSugadd.handleFtSugadd(e, a)],
   ['FT.SUGGET', (e, a) => ftSugget.handleFtSugget(e, a)],

package/src/storage/sqlite/search.js

@@ -154,7 +154,11 @@ export function addDocument(db, idx, docId, score, replace, fields) {
     let ftsRowid;
     if (existing) {
       if (!replace) throw new Error('ERR document exists');
-      ftsRowid = existing.fts_rowid;
+      // FTS5 contentless bug: INSERT OR REPLACE doesn't remove old tokens.
+      // Solution: assign a new fts_rowid to avoid token pollution.
+      const maxRow = db.prepare(`SELECT COALESCE(MAX(fts_rowid), 0) AS m FROM ${docmapT}`).get();
+      ftsRowid = maxRow.m + 1;
+      db.prepare(`UPDATE ${docmapT} SET fts_rowid = ? WHERE doc_id = ?`).run(ftsRowid, docId);
     } else {
       const maxRow = db.prepare(`SELECT COALESCE(MAX(fts_rowid), 0) AS m FROM ${docmapT}`).get();
       ftsRowid = maxRow.m + 1;
@@ -172,12 +176,12 @@ export function addDocument(db, idx, docId, score, replace, fields) {
       ).run(docId, score, fieldsJson, now, now);
     }
 
-    // FTS5 contentless: cannot DELETE; use INSERT OR REPLACE to overwrite by rowid when replacing.
+    // FTS5 contentless: insert with new rowid (old rowid becomes orphaned and won't match via docmap join).
     const ftsColumns = ['rowid', ...fieldNames.sort()];
     const ftsValues = [ftsRowid, ...fieldNames.sort().map((f) => fields[f] ?? '')];
     const placeholders = ftsValues.map(() => '?').join(', ');
     const colList = ftsColumns.join(', ');
-    db.prepare(`INSERT OR REPLACE INTO ${ftsT}(${colList}) VALUES (${placeholders})`).run(...ftsValues);
+    db.prepare(`INSERT INTO ${ftsT}(${colList}) VALUES (${placeholders})`).run(...ftsValues);
   });
 
   run();
@@ -190,6 +194,29 @@ export function addDocument(db, idx, docId, score, replace, fields) {
  * @param {string} docId
  * @returns {number}
  */
+/**
+ * Load stored fields for FT.GET: flat [field, value, ...] in schema field order.
+ * RediSearch-compatible: empty string values encode as null in RESP.
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} idx
+ * @param {string} docId
+ * @returns { (string|null)[] | null } - null if document is not in the index
+ */
+export function getDocumentFields(db, idx, docId) {
+  const meta = getIndexMeta(db, idx);
+  const docsT = tableName(idx, 'docs');
+  const row = db.prepare(`SELECT fields_json FROM ${docsT} WHERE doc_id = ?`).get(docId);
+  if (!row) return null;
+  const fields = JSON.parse(row.fields_json);
+  const flat = [];
+  for (const f of meta.schema.fields) {
+    if (!Object.prototype.hasOwnProperty.call(fields, f.name)) continue;
+    const v = fields[f.name];
+    flat.push(f.name, v === '' ? null : v);
+  }
+  return flat;
+}
+
 export function deleteDocument(db, idx, docId) {
   getIndexMeta(db, idx);
   const docsT = tableName(idx, 'docs');

package/test/integration/search.test.js

@@ -39,6 +39,17 @@ describe('Search integration', () => {
     assert.equal(tryParseValue(ok, 0).value, 'OK');
   });
 
+  it('FT.GET returns field array for indexed doc and nil when missing', async () => {
+    const miss = await sendCommand(port, argv('FT.GET', 'names', 'no-such'));
+    assert.equal(tryParseValue(miss, 0).value, null);
+
+    const hit = await sendCommand(port, argv('FT.GET', 'names', 'DY1O2'));
+    const arr = tryParseValue(hit, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.equal(arr[0].toString?.('utf8') ?? arr[0], 'payload');
+    assert.equal(arr[1].toString?.('utf8') ?? arr[1], 'martin clasen');
+  });
+
   it('FT.SEARCH returns NOCONTENT shape and total', async () => {
     const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'clasen', 'NOCONTENT', 'LIMIT', '0', '25'));
     const arr = tryParseValue(reply, 0).value;
@@ -185,6 +196,40 @@ describe('Search integration', () => {
     const err = v?.error ?? v;
     assert.ok(String(err).includes('Unknown index name'));
   });
+
+  it('FT.SEARCH prefix query should not match unrelated terms', async () => {
+    // Create a fresh index for this test
+    await sendCommand(port, argv('FT.CREATE', 'bugtest', 'SCHEMA', 'payload', 'TEXT'));
+    
+    // Add document with "gorge" first
+    await sendCommand(port, argv('FT.ADD', 'bugtest', 'DOC1', '1', 'REPLACE', 'FIELDS', 'payload', 'gorge'));
+    
+    // Verify it matches gorge*
+    const gorge1 = await sendCommand(port, argv('FT.SEARCH', 'bugtest', 'gorge*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const g1 = tryParseValue(gorge1, 0).value;
+    assert.equal(g1[0], 1, 'gorge* should match gorge');
+    assert.equal(g1[1].toString?.('utf8') ?? g1[1], 'DOC1');
+    
+    // Replace with "martan"
+    await sendCommand(port, argv('FT.ADD', 'bugtest', 'DOC1', '1', 'REPLACE', 'FIELDS', 'payload', 'martan'));
+    
+    // Verify FT.GET shows only martan
+    const get = await sendCommand(port, argv('FT.GET', 'bugtest', 'DOC1'));
+    const getArr = tryParseValue(get, 0).value;
+    assert.equal(getArr[0].toString?.('utf8') ?? getArr[0], 'payload');
+    assert.equal(getArr[1].toString?.('utf8') ?? getArr[1], 'martan');
+    
+    // martan* should match
+    const martan = await sendCommand(port, argv('FT.SEARCH', 'bugtest', 'martan*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const m = tryParseValue(martan, 0).value;
+    assert.equal(m[0], 1, 'martan* should match martan');
+    assert.equal(m[1].toString?.('utf8') ?? m[1], 'DOC1');
+    
+    // gorge* should NOT match martan
+    const gorge2 = await sendCommand(port, argv('FT.SEARCH', 'bugtest', 'gorge*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const g2 = tryParseValue(gorge2, 0).value;
+    assert.equal(g2[0], 0, 'gorge* should NOT match martan - this is the bug');
+  });
 });
 
 describe('Search persistence', () => {

package/test/unit/ft-parser.test.js

@@ -5,6 +5,7 @@ import {
   parseFtInfo,
   parseFtAdd,
   parseFtDel,
+  parseFtGet,
   parseFtSearch,
   parseFtSugadd,
   parseFtSugget,
@@ -117,6 +118,20 @@ describe('FT parser', () => {
     });
   });
 
+  describe('parseFtGet', () => {
+    it('accepts index and doc_id', () => {
+      const r = parseFtGet([buf('names'), buf('doc1')]);
+      assert.ok(!r.error);
+      assert.equal(r.indexName, 'names');
+      assert.equal(r.docId, 'doc1');
+    });
+
+    it('rejects wrong number of args', () => {
+      assert.equal(parseFtGet([buf('a')]).error, 'ERR syntax error');
+      assert.equal(parseFtGet([buf('a'), buf('b'), buf('c')]).error, 'ERR syntax error');
+    });
+  });
+
   describe('parseFtSearch', () => {
     it('accepts index and query', () => {
       const r = parseFtSearch([buf('names'), buf('hello')]);

package/test/unit/search.test.js

@@ -6,6 +6,7 @@ import {
   getIndexMeta,
   getIndexCounts,
   addDocument,
+  getDocumentFields,
   deleteDocument,
   search,
   suggestionAdd,
@@ -63,6 +64,23 @@ describe('Search layer', () => {
     assert.throws(() => addDocument(db, 'names', 'doc3', 1, true, { payload: 'x', unknown: 'y' }), /unknown field/);
   });
 
+  it('getDocumentFields returns null when doc missing, flat array in schema order', () => {
+    assert.equal(getDocumentFields(db, 'names', 'no-such-doc'), null);
+    addDocument(db, 'names', 'gd1', 1, true, { payload: 'hello' });
+    assert.deepEqual(getDocumentFields(db, 'names', 'gd1'), ['payload', 'hello']);
+    addDocument(db, 'names', 'gd2', 1, true, { payload: '' });
+    assert.deepEqual(getDocumentFields(db, 'names', 'gd2'), ['payload', null]);
+  });
+
+  it('getDocumentFields multi-field schema order', () => {
+    createIndex(db, 'mf', [
+      { name: 'payload', type: 'TEXT' },
+      { name: 'title', type: 'TEXT' },
+    ]);
+    addDocument(db, 'mf', 'm1', 1, true, { payload: 'pval', title: 'tval' });
+    assert.deepEqual(getDocumentFields(db, 'mf', 'm1'), ['payload', 'pval', 'title', 'tval']);
+  });
+
   it('deleteDocument returns 1 when found, 0 when not', () => {
     addDocument(db, 'names', 'todel', 1, true, { payload: 'to delete' });
     assert.equal(deleteDocument(db, 'names', 'todel'), 1);