resplite 1.4.8 → 1.4.10

package/package.json

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

package/skills/{resplite-command-vertical-slice → resplite}/SKILL.md

@@ -1,12 +1,9 @@
 ---
-name: resplite-command-vertical-slice
+name: resplite
 description: Implements or extends a Redis-like command in RESPLite from spec to docs and tests. Use when the user says "add a command", "support a Redis option", "fix command compatibility", "implement ZRANGE behavior", or "update the compatibility matrix". Do not use for migration-only or FT-only work unless the change also affects the general command surface.
-license: MIT
 metadata:
-  author: Cursor Agent
-  version: 1.0.0
   category: workflow-automation
-  tags: [resplite, redis-compatibility, commands, tests]
+  tags: [resplite, redis, commands, tests]
 ---
 
 # RESPLite Command Vertical Slice

package/skills/{resplite-ft-search-workbench → resplite-ft-search}/SKILL.md

@@ -1,10 +1,7 @@
 ---
-name: resplite-ft-search-workbench
+name: resplite-ft-search
 description: Builds or refines RESPLite `FT.*` behavior and RediSearch migration mapping on top of SQLite FTS5. Use when the user says "add FT command support", "fix FT.SEARCH", "adjust SQLite FTS5 behavior", "migrate RediSearch indices", or "work on FT.CREATE or FT.ADD semantics". Do not use for unrelated command work outside the search surface.
-license: MIT
 metadata:
-  author: Cursor Agent
-  version: 1.0.0
   category: workflow-automation
   tags: [resplite, search, redisearch, sqlite, fts5]
 ---

package/skills/{resplite-migration-cutover-assistant → resplite-migration}/SKILL.md

@@ -1,10 +1,7 @@
 ---
-name: resplite-migration-cutover-assistant
+name: resplite-migration
 description: Guides Redis to RESPLite migration work using the programmatic migration API, dirty-key tracking, cutover, and verification. Use when the user says "migrate Redis", "dirty tracker", "cutover", "resume bulk import", "verify migration", or "move RediSearch data during migration". Do not use for generic command work that does not touch the migration flow.
-license: MIT
 metadata:
-  author: Cursor Agent
-  version: 1.0.0
   category: workflow-automation
   tags: [resplite, migration, redis, cutover, verification]
 ---

package/src/storage/sqlite/search.js

@@ -209,21 +209,64 @@ export function deleteDocument(db, idx, docId) {
 }
 
 /**
- * Validate and build FTS5 MATCH expression. D.13.2: allow tokens [A-Za-z0-9_]+ optionally ending with *
- * Reject chars that break MATCH: " ' : ( ) [ ] { } \ and non-printable.
+ * Build a safe FTS5 MATCH expression from user query.
+ *
+ * We intentionally normalize punctuation so query tokenization is flexible and
+ * closer to Redis/RediSearch behavior for common free-text searches:
+ * - punctuation like ".", "#", "+", "/", ",", "(", ")" acts as separators
+ * - "?" is ignored as punctuation
+ * - "-" inside terms acts as separator (hello-world -> hello world)
+ * - "-term" (leading minus) maps to boolean NOT term
+ * - "@" and ":" are treated as unsupported query syntax and return syntax error
+ *
+ * Supported term chars are unicode letters/digits plus underscore, with
+ * optional trailing "*" for prefix queries.
+ *
+ * Reject control characters and unsafe MATCH breakers: " ' \ and non-printable.
  * @param {string} query
- * @returns {string} - Safe MATCH expression e.g. "martin clasen*"
+ * @returns {string} - Safe MATCH expression e.g. "martin NOT clasen*"
  */
 function buildMatchExpression(query) {
   if (typeof query !== 'string') throw new Error('ERR invalid query');
   const trimmed = query.trim();
   if (trimmed === '') throw new Error('ERR invalid query');
-  if (/["':()\[\]{}\\]/.test(query) || /[\x00-\x1f]/.test(query)) throw new Error('ERR invalid query');
-  const tokens = trimmed.split(/\s+/).filter(Boolean);
-  for (const t of tokens) {
-    if (!/^[A-Za-z0-9_]*\*?$/.test(t)) throw new Error('ERR invalid query');
+  if (/[\x00-\x1f]/.test(query) || /["'\\]/.test(query)) throw new Error('ERR invalid query');
+  if (query.includes('@') || query.includes(':')) throw new Error('ERR syntax error');
+
+  const normalized = trimmed
+    .replace(/\?/g, '')
+    .replace(/[^\p{L}\p{N}_*\-\s]+/gu, ' ')
+    .trim();
+  const rawTokens = normalized.split(/\s+/).filter(Boolean);
+  if (rawTokens.length === 0) throw new Error('ERR invalid query');
+
+  const termRe = /^[\p{L}\p{N}_]+\*?$/u;
+  const tokens = [];
+
+  for (const raw of rawTokens) {
+    if (raw.startsWith('-')) {
+      const neg = raw.slice(1);
+      if (!neg || neg.includes('-') || !termRe.test(neg)) throw new Error('ERR invalid query');
+      tokens.push('NOT', neg);
+      continue;
+    }
+    const segments = raw.split('-').filter(Boolean);
+    if (segments.length === 0) throw new Error('ERR invalid query');
+    for (const seg of segments) {
+      if (!termRe.test(seg)) throw new Error('ERR invalid query');
+      tokens.push(seg);
+    }
+  }
+
+  for (let i = 0; i < tokens.length; i += 1) {
+    if (tokens[i] === 'NOT') {
+      if (i === 0 || i === tokens.length - 1 || tokens[i + 1] === 'NOT') {
+        throw new Error('ERR invalid query');
+      }
+    }
   }
-  return trimmed;
+
+  return tokens.join(' ');
 }
 
 /**

package/test/integration/search.test.js

@@ -55,6 +55,72 @@ describe('Search integration', () => {
     assert.ok(arr[0] >= 0);
   });
 
+  it('FT.SEARCH dotted prefix query works', async () => {
+    const ok = await sendCommand(
+      port,
+      argv('FT.ADD', 'names', 'MAIL1', '1', 'REPLACE', 'FIELDS', 'payload', 'martin clasen martin.clasen@gmail.com')
+    );
+    assert.equal(tryParseValue(ok, 0).value, 'OK');
+
+    const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin.clasen*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const arr = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.ok(arr[0] >= 1);
+    const docIds = arr.slice(1).map((v) => (v?.toString ? v.toString('utf8') : String(v)));
+    assert.ok(docIds.includes('MAIL1'));
+  });
+
+  it('FT.SEARCH handles punctuation tokenization flexibly', async () => {
+    const ok = await sendCommand(
+      port,
+      argv(
+        'FT.ADD',
+        'names',
+        'CHARS1',
+        '1',
+        'REPLACE',
+        'FIELDS',
+        'payload',
+        'martin-clasen martin@clasen.com #martin who? alpha+beta foo/bar baz,qux'
+      )
+    );
+    assert.equal(tryParseValue(ok, 0).value, 'OK');
+
+    for (const q of ['who?', 'alpha+beta', 'foo/bar', 'baz,qux', '(martin)', '#martin*']) {
+      const reply = await sendCommand(port, argv('FT.SEARCH', 'names', q, 'NOCONTENT', 'LIMIT', '0', '10'));
+      const arr = tryParseValue(reply, 0).value;
+      assert.ok(Array.isArray(arr));
+      const docIds = arr.slice(1).map((v) => (v?.toString ? v.toString('utf8') : String(v)));
+      assert.ok(docIds.includes('CHARS1'));
+    }
+  });
+
+  it('FT.SEARCH keeps Redis-like syntax errors for @ and :', async () => {
+    const atReply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin@clasen*', 'NOCONTENT'));
+    const atVal = tryParseValue(atReply, 0).value;
+    const atErr = String(atVal?.error ?? atVal);
+    assert.ok(atErr.includes('syntax error'));
+
+    const colonReply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin:clasen', 'NOCONTENT'));
+    const colonVal = tryParseValue(colonReply, 0).value;
+    const colonErr = String(colonVal?.error ?? colonVal);
+    assert.ok(colonErr.includes('syntax error'));
+  });
+
+  it('FT.SEARCH treats hyphen inside term as separator', async () => {
+    const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin-clasen*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const arr = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.ok(arr[0] >= 1);
+  });
+
+  it('FT.SEARCH keeps NOT semantics for leading minus', async () => {
+    const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin -clasen*', 'NOCONTENT', 'LIMIT', '0', '10'));
+    const arr = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(arr));
+    assert.equal(arr[0], 0);
+  });
+
   it('FT.SEARCH LIMIT applies', async () => {
     const reply = await sendCommand(port, argv('FT.SEARCH', 'names', 'martin', 'NOCONTENT', 'LIMIT', '0', '1'));
     const arr = tryParseValue(reply, 0).value;

package/test/integration/sets.test.js

@@ -52,6 +52,34 @@ describe('Sets integration', () => {
     assert.equal(tryParseValue(reply, 0).value, 3);
   });
 
+  it('concurrent SADD of same member is idempotent', async () => {
+    const key = `scon:sadd:${Date.now()}`;
+    const N = 25;
+    const replies = await Promise.all(Array.from({ length: N }, () => sendCommand(port, argv('SADD', key, 'x'))));
+    const addedCounts = replies.map((reply) => tryParseValue(reply, 0).value);
+    const firstAdds = addedCounts.filter((n) => n === 1).length;
+    const duplicateAdds = addedCounts.filter((n) => n === 0).length;
+    assert.equal(firstAdds, 1);
+    assert.equal(duplicateAdds, N - 1);
+    const card = await sendCommand(port, argv('SCARD', key));
+    assert.equal(tryParseValue(card, 0).value, 1);
+  });
+
+  it('concurrent SPOP returns unique members and drains set', async () => {
+    const key = `scon:spop:${Date.now()}`;
+    const members = Array.from({ length: 24 }, (_, i) => `m${i}`);
+    await sendCommand(port, argv('SADD', key, ...members));
+    const poppedRaw = await Promise.all(Array.from({ length: members.length }, () => sendCommand(port, argv('SPOP', key))));
+    const popped = poppedRaw.map((reply) => {
+      const parsed = tryParseValue(reply, 0);
+      return parsed.value === null ? null : parsed.value.toString('utf8');
+    });
+    assert.equal(popped.includes(null), false);
+    assert.equal(new Set(popped).size, members.length);
+    const card = await sendCommand(port, argv('SCARD', key));
+    assert.equal(tryParseValue(card, 0).value, 0);
+  });
+
   it('legacy set rows with null set_count hydrate on first SCARD', async () => {
     const s1 = await createTestServer();
     await sendCommand(s1.port, argv('SADD', 'legacy:s', 'a', 'b'));

package/test/unit/search.test.js

@@ -92,9 +92,43 @@ describe('Search layer', () => {
     assert.ok(Array.isArray(r.docIds));
   });
 
+  it('search dotted prefix query works', () => {
+    addDocument(db, 'names', 'mail1', 1, true, { payload: 'martin clasen martin.clasen@gmail.com' });
+    const r = search(db, 'names', 'martin.clasen*', { noContent: true });
+    assert.ok(r.total >= 1);
+    assert.ok(r.docIds.includes('mail1'));
+  });
+
+  it('search tokenization stays flexible across punctuation', () => {
+    addDocument(db, 'names', 'chars1', 1, true, {
+      payload: 'martin-clasen martin@clasen.com #martin who? alpha+beta foo/bar baz,qux',
+    });
+    assert.ok(search(db, 'names', 'who?', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', 'alpha+beta', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', 'foo/bar', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', 'baz,qux', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', '(martin)', { noContent: true }).docIds.includes('chars1'));
+    assert.ok(search(db, 'names', '#martin*', { noContent: true }).docIds.includes('chars1'));
+  });
+
+  it('search hyphen inside term is treated as separator', () => {
+    addDocument(db, 'names', 'hyphen1', 1, true, { payload: 'martin clasen' });
+    const r = search(db, 'names', 'martin-clasen*', { noContent: true });
+    assert.ok(r.total >= 1);
+    assert.ok(r.docIds.includes('hyphen1'));
+  });
+
+  it('search leading minus uses NOT operator semantics', () => {
+    addDocument(db, 'names', 'neg1', 1, true, { payload: 'martin clasen' });
+    const r = search(db, 'names', 'martin -clasen*', { noContent: true });
+    assert.equal(r.total, 0);
+  });
+
   it('search invalid query throws', () => {
     assert.throws(() => search(db, 'names', ''), /invalid query/);
     assert.throws(() => search(db, 'names', 'foo"bar'), /invalid query/);
+    assert.throws(() => search(db, 'names', 'martin@clasen*'), /syntax error/);
+    assert.throws(() => search(db, 'names', 'martin:clasen'), /syntax error/);
   });
 
   it('suggestionAdd returns 1 on insert, 0 on update', () => {