resplite 1.4.8 → 1.4.12

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.8",
+  "version": "1.4.12",
   "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/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

@@ -190,6 +190,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');
@@ -209,21 +232,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);
+    }
   }
-  return trimmed;
+
+  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 tokens.join(' ');
 }
 
 /**

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;
@@ -55,6 +66,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/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);
@@ -92,9 +110,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', () => {