@nixxie-cms/search 1.0.1

package/dist/nixxie-cms-search.esm.js

@@ -0,0 +1,424 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+
+/** Algolia backend over the REST API (no SDK dependency). */
+class AlgoliaSearch {
+  constructor(config) {
+    this.appId = config.appId;
+    this.apiKey = config.apiKey;
+  }
+  headers() {
+    return {
+      'Content-Type': 'application/json',
+      'X-Algolia-API-Key': this.apiKey,
+      'X-Algolia-Application-Id': this.appId
+    };
+  }
+  writeHost() {
+    return `https://${this.appId}.algolia.net`;
+  }
+  readHost() {
+    return `https://${this.appId}-dsn.algolia.net`;
+  }
+  async index(indexName, documents) {
+    const docs = Array.isArray(documents) ? documents : [documents];
+    const requests = docs.map(d => ({
+      action: 'updateObject',
+      body: {
+        ...d,
+        objectID: d.id
+      }
+    }));
+    const res = await fetch(`${this.writeHost()}/1/indexes/${indexName}/batch`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({
+        requests
+      })
+    });
+    if (!res.ok) throw new Error(`Algolia index failed (${res.status}): ${await res.text()}`);
+  }
+  async remove(indexName, id) {
+    await fetch(`${this.writeHost()}/1/indexes/${indexName}/${encodeURIComponent(id)}`, {
+      method: 'DELETE',
+      headers: this.headers()
+    });
+  }
+  async search(indexName, query) {
+    var _query$offset, _query$limit, _data$hits, _ref, _data$nbHits, _data$hits2;
+    const filters = query.filter ? Object.entries(query.filter).map(([k, v]) => `${k}:${JSON.stringify(v)}`).join(' AND ') : undefined;
+    const res = await fetch(`${this.readHost()}/1/indexes/${indexName}/query`, {
+      method: 'POST',
+      headers: this.headers(),
+      // Algolia's two pagination modes are mutually exclusive: page+hitsPerPage OR offset+length.
+      // Mixing them returns HTTP 400, so use offset/length only.
+      body: JSON.stringify({
+        query: query.q,
+        offset: (_query$offset = query.offset) !== null && _query$offset !== void 0 ? _query$offset : 0,
+        length: (_query$limit = query.limit) !== null && _query$limit !== void 0 ? _query$limit : 20,
+        filters
+      })
+    });
+    if (!res.ok) throw new Error(`Algolia search failed (${res.status}): ${await res.text()}`);
+    const data = await res.json();
+    return {
+      hits: ((_data$hits = data.hits) !== null && _data$hits !== void 0 ? _data$hits : []).map(h => {
+        var _h$_rankingInfo;
+        return {
+          document: {
+            ...h,
+            id: h.objectID
+          },
+          score: (_h$_rankingInfo = h._rankingInfo) === null || _h$_rankingInfo === void 0 ? void 0 : _h$_rankingInfo.userScore
+        };
+      }),
+      total: (_ref = (_data$nbHits = data.nbHits) !== null && _data$nbHits !== void 0 ? _data$nbHits : (_data$hits2 = data.hits) === null || _data$hits2 === void 0 ? void 0 : _data$hits2.length) !== null && _ref !== void 0 ? _ref : 0,
+      tookMs: data.processingTimeMS
+    };
+  }
+  async clear(indexName) {
+    await fetch(`${this.writeHost()}/1/indexes/${indexName}/clear`, {
+      method: 'POST',
+      headers: this.headers()
+    });
+  }
+  async close() {}
+}
+
+/** Elasticsearch backend over the REST API (no SDK dependency). */
+class ElasticsearchSearch {
+  constructor(config) {
+    this.node = config.node.replace(/\/$/, '');
+    if (config.apiKey) this.authHeader = `ApiKey ${config.apiKey}`;else if (config.username && config.password) {
+      this.authHeader = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`;
+    }
+  }
+  async request(path, method, body) {
+    const res = await fetch(`${this.node}${path}`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.authHeader ? {
+          Authorization: this.authHeader
+        } : {})
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`Elasticsearch request failed (${res.status}): ${await res.text()}`);
+    }
+    return res.status === 404 ? undefined : res.json();
+  }
+  async index(indexName, documents) {
+    const docs = Array.isArray(documents) ? documents : [documents];
+    const body = docs.map(d => `${JSON.stringify({
+      index: {
+        _index: indexName,
+        _id: d.id
+      }
+    })}\n${JSON.stringify(d)}`).join('\n') + '\n';
+    const res = await fetch(`${this.node}/_bulk?refresh=true`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-ndjson',
+        ...(this.authHeader ? {
+          Authorization: this.authHeader
+        } : {})
+      },
+      body
+    });
+    if (!res.ok) throw new Error(`Elasticsearch bulk failed (${res.status}): ${await res.text()}`);
+  }
+  async remove(indexName, id) {
+    await this.request(`/${indexName}/_doc/${encodeURIComponent(id)}?refresh=true`, 'DELETE');
+  }
+  async search(indexName, query) {
+    var _query$sort, _query$offset, _query$limit, _res$hits$hits, _res$hits, _res$hits2, _res$hits$total, _res$hits3;
+    const must = [query.q ? {
+      multi_match: {
+        query: query.q,
+        fields: ['*']
+      }
+    } : {
+      match_all: {}
+    }];
+    const filter = query.filter ? Object.entries(query.filter).map(([k, v]) => ({
+      term: {
+        [k]: v
+      }
+    })) : [];
+    const sort = (_query$sort = query.sort) === null || _query$sort === void 0 ? void 0 : _query$sort.map(s => {
+      const [field, dir = 'asc'] = s.split(':');
+      return {
+        [field]: dir
+      };
+    });
+    const res = await this.request(`/${indexName}/_search`, 'POST', {
+      from: (_query$offset = query.offset) !== null && _query$offset !== void 0 ? _query$offset : 0,
+      size: (_query$limit = query.limit) !== null && _query$limit !== void 0 ? _query$limit : 20,
+      query: {
+        bool: {
+          must,
+          filter
+        }
+      },
+      sort
+    });
+    const hits = (_res$hits$hits = res === null || res === void 0 || (_res$hits = res.hits) === null || _res$hits === void 0 ? void 0 : _res$hits.hits) !== null && _res$hits$hits !== void 0 ? _res$hits$hits : [];
+    return {
+      hits: hits.map(h => ({
+        document: {
+          ...h._source,
+          id: h._id
+        },
+        score: h._score
+      })),
+      total: typeof (res === null || res === void 0 || (_res$hits2 = res.hits) === null || _res$hits2 === void 0 ? void 0 : _res$hits2.total) === 'object' ? res.hits.total.value : (_res$hits$total = res === null || res === void 0 || (_res$hits3 = res.hits) === null || _res$hits3 === void 0 ? void 0 : _res$hits3.total) !== null && _res$hits$total !== void 0 ? _res$hits$total : 0,
+      tookMs: res === null || res === void 0 ? void 0 : res.took
+    };
+  }
+  async clear(indexName) {
+    await this.request(`/${indexName}/_delete_by_query?refresh=true`, 'POST', {
+      query: {
+        match_all: {}
+      }
+    });
+  }
+  async close() {}
+}
+
+/**
+ * Zero-dependency in-memory search. Tokenises stringified document values and ranks by the
+ * number of query terms matched. Intended for development, tests and small datasets — swap in a
+ * real engine (Meilisearch/Typesense/Algolia/Elasticsearch) for production.
+ */
+class InMemorySearch {
+  constructor() {
+    _defineProperty(this, "indexes", new Map());
+  }
+  indexFor(name) {
+    let idx = this.indexes.get(name);
+    if (!idx) {
+      idx = new Map();
+      this.indexes.set(name, idx);
+    }
+    return idx;
+  }
+  async index(indexName, documents) {
+    const idx = this.indexFor(indexName);
+    for (const doc of Array.isArray(documents) ? documents : [documents]) {
+      if (!doc.id) throw new Error('Search documents must have an `id`');
+      idx.set(doc.id, doc);
+    }
+  }
+  async remove(indexName, id) {
+    var _this$indexes$get;
+    (_this$indexes$get = this.indexes.get(indexName)) === null || _this$indexes$get === void 0 || _this$indexes$get.delete(id);
+  }
+  async search(indexName, query) {
+    var _query$sort, _query$offset, _query$limit;
+    const start = Date.now();
+    const idx = this.indexes.get(indexName);
+    const terms = query.q.toLowerCase().split(/\s+/).filter(Boolean);
+    const matched = [];
+    for (const doc of (_idx$values = idx === null || idx === void 0 ? void 0 : idx.values()) !== null && _idx$values !== void 0 ? _idx$values : []) {
+      var _idx$values;
+      if (query.filter && !this.matchesFilter(doc, query.filter)) continue;
+      const haystack = JSON.stringify(doc).toLowerCase();
+      const score = terms.length === 0 ? 1 : terms.filter(t => haystack.includes(t)).length;
+      if (terms.length === 0 || score > 0) matched.push({
+        document: doc,
+        score
+      });
+    }
+    matched.sort((a, b) => b.score - a.score);
+    if ((_query$sort = query.sort) !== null && _query$sort !== void 0 && _query$sort.length) this.applySort(matched, query.sort);
+    const offset = (_query$offset = query.offset) !== null && _query$offset !== void 0 ? _query$offset : 0;
+    const limit = (_query$limit = query.limit) !== null && _query$limit !== void 0 ? _query$limit : 20;
+    const page = matched.slice(offset, offset + limit);
+    return {
+      hits: page.map(m => ({
+        document: m.document,
+        score: m.score
+      })),
+      total: matched.length,
+      tookMs: Date.now() - start
+    };
+  }
+  async clear(indexName) {
+    var _this$indexes$get2;
+    (_this$indexes$get2 = this.indexes.get(indexName)) === null || _this$indexes$get2 === void 0 || _this$indexes$get2.clear();
+  }
+  async close() {
+    this.indexes.clear();
+  }
+  matchesFilter(doc, filter) {
+    return Object.entries(filter).every(([k, v]) => doc[k] === v);
+  }
+  applySort(items, sort) {
+    items.sort((a, b) => {
+      for (const spec of sort) {
+        const [attr, dir = 'asc'] = spec.split(':');
+        const av = a.document[attr];
+        const bv = b.document[attr];
+        if (av === bv) continue;
+        const cmp = av > bv ? 1 : -1;
+        return dir === 'desc' ? -cmp : cmp;
+      }
+      return 0;
+    });
+  }
+}
+
+/** Meilisearch backend over the REST API (no SDK dependency). */
+class MeilisearchSearch {
+  constructor(config) {
+    this.base = config.url.replace(/\/$/, '');
+    this.apiKey = config.apiKey;
+  }
+  async request(path, method, body) {
+    const res = await fetch(`${this.base}${path}`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.apiKey ? {
+          Authorization: `Bearer ${this.apiKey}`
+        } : {})
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`Meilisearch request failed (${res.status}): ${await res.text()}`);
+    }
+    return res.status === 404 ? undefined : res.json();
+  }
+  async index(indexName, documents) {
+    const docs = Array.isArray(documents) ? documents : [documents];
+    await this.request(`/indexes/${indexName}/documents`, 'POST', docs);
+  }
+  async remove(indexName, id) {
+    await this.request(`/indexes/${indexName}/documents/${encodeURIComponent(id)}`, 'DELETE');
+  }
+  async search(indexName, query) {
+    var _query$limit, _query$offset, _res$hits, _ref, _res$estimatedTotalHi, _res$hits2;
+    const filter = query.filter ? Object.entries(query.filter).map(([k, v]) => `${k} = ${JSON.stringify(v)}`) : undefined;
+    const res = await this.request(`/indexes/${indexName}/search`, 'POST', {
+      q: query.q,
+      limit: (_query$limit = query.limit) !== null && _query$limit !== void 0 ? _query$limit : 20,
+      offset: (_query$offset = query.offset) !== null && _query$offset !== void 0 ? _query$offset : 0,
+      filter,
+      sort: query.sort
+    });
+    return {
+      hits: ((_res$hits = res === null || res === void 0 ? void 0 : res.hits) !== null && _res$hits !== void 0 ? _res$hits : []).map(document => ({
+        document
+      })),
+      total: (_ref = (_res$estimatedTotalHi = res === null || res === void 0 ? void 0 : res.estimatedTotalHits) !== null && _res$estimatedTotalHi !== void 0 ? _res$estimatedTotalHi : res === null || res === void 0 || (_res$hits2 = res.hits) === null || _res$hits2 === void 0 ? void 0 : _res$hits2.length) !== null && _ref !== void 0 ? _ref : 0,
+      tookMs: res === null || res === void 0 ? void 0 : res.processingTimeMs
+    };
+  }
+  async clear(indexName) {
+    await this.request(`/indexes/${indexName}/documents`, 'DELETE');
+  }
+  async close() {}
+}
+
+/**
+ * Typesense backend over the REST API (no SDK dependency).
+ * Collections must already exist; documents are upserted. Typesense has no wildcard `query_by`,
+ * so configure `queryBy` to match your collection's searchable fields.
+ * Note: `clear()` drops the entire collection (Typesense has no schema-preserving truncate),
+ * so recreate the collection before re-indexing.
+ */
+class TypesenseSearch {
+  constructor(config) {
+    var _config$protocol, _config$port, _config$queryBy;
+    const protocol = (_config$protocol = config.protocol) !== null && _config$protocol !== void 0 ? _config$protocol : 'http';
+    const port = (_config$port = config.port) !== null && _config$port !== void 0 ? _config$port : 8108;
+    this.base = `${protocol}://${config.host}:${port}`;
+    this.apiKey = config.apiKey;
+    this.queryBy = (_config$queryBy = config.queryBy) !== null && _config$queryBy !== void 0 ? _config$queryBy : 'title,name,body,content';
+  }
+  headers() {
+    return {
+      'Content-Type': 'application/json',
+      'X-TYPESENSE-API-KEY': this.apiKey
+    };
+  }
+  async index(indexName, documents) {
+    const docs = Array.isArray(documents) ? documents : [documents];
+    const body = docs.map(d => JSON.stringify(d)).join('\n');
+    const res = await fetch(`${this.base}/collections/${indexName}/documents/import?action=upsert`, {
+      method: 'POST',
+      headers: this.headers(),
+      body
+    });
+    if (!res.ok) throw new Error(`Typesense import failed (${res.status}): ${await res.text()}`);
+  }
+  async remove(indexName, id) {
+    await fetch(`${this.base}/collections/${indexName}/documents/${encodeURIComponent(id)}`, {
+      method: 'DELETE',
+      headers: this.headers()
+    });
+  }
+  async search(indexName, query) {
+    var _query$limit, _query$offset, _query$sort, _data$hits, _data$found;
+    // Use Typesense's `offset`/`limit` params (supported since v0.23) rather than `page`/`per_page`,
+    // so arbitrary, non-page-aligned offsets return the correct window.
+    const params = new URLSearchParams({
+      q: query.q,
+      query_by: this.queryBy,
+      limit: String((_query$limit = query.limit) !== null && _query$limit !== void 0 ? _query$limit : 20),
+      offset: String((_query$offset = query.offset) !== null && _query$offset !== void 0 ? _query$offset : 0)
+    });
+    if (query.filter) {
+      params.set('filter_by', Object.entries(query.filter).map(([k, v]) => `${k}:=${JSON.stringify(v)}`).join(' && '));
+    }
+    if ((_query$sort = query.sort) !== null && _query$sort !== void 0 && _query$sort.length) params.set('sort_by', query.sort.join(','));
+    const res = await fetch(`${this.base}/collections/${indexName}/documents/search?${params}`, {
+      headers: this.headers()
+    });
+    if (!res.ok) throw new Error(`Typesense search failed (${res.status}): ${await res.text()}`);
+    const data = await res.json();
+    return {
+      hits: ((_data$hits = data.hits) !== null && _data$hits !== void 0 ? _data$hits : []).map(h => ({
+        document: h.document,
+        score: h.text_match
+      })),
+      total: (_data$found = data.found) !== null && _data$found !== void 0 ? _data$found : 0,
+      tookMs: data.search_time_ms
+    };
+  }
+  async clear(indexName) {
+    const res = await fetch(`${this.base}/collections/${indexName}`, {
+      method: 'DELETE',
+      headers: this.headers()
+    });
+    // A missing collection (404) is already "cleared"; anything else is a real failure.
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`Typesense clear failed (${res.status}): ${await res.text()}`);
+    }
+  }
+  async close() {}
+}
+
+function createSearch(config) {
+  switch (config.driver) {
+    case 'memory':
+      return new InMemorySearch();
+    case 'meilisearch':
+      return new MeilisearchSearch(config);
+    case 'typesense':
+      return new TypesenseSearch(config);
+    case 'algolia':
+      return new AlgoliaSearch(config);
+    case 'elasticsearch':
+      return new ElasticsearchSearch(config);
+    default:
+      {
+        const exhaustive = config;
+        throw new Error(`Unknown search driver: ${exhaustive.driver}`);
+      }
+  }
+}
+
+export { AlgoliaSearch, ElasticsearchSearch, InMemorySearch, MeilisearchSearch, TypesenseSearch, createSearch };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@nixxie-cms/search",
+  "version": "1.0.1",
+  "license": "MIT",
+  "main": "dist/nixxie-cms-search.cjs.js",
+  "module": "dist/nixxie-cms-search.esm.js",
+  "exports": {
+    ".": {
+      "types": "./dist/nixxie-cms-search.cjs.js",
+      "module": "./dist/nixxie-cms-search.esm.js",
+      "default": "./dist/nixxie-cms-search.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.24.7"
+  },
+  "devDependencies": {
+    "@nixxie-cms/core": "^1.0.1"
+  },
+  "peerDependencies": {
+    "@nixxie-cms/core": "^1.0.1"
+  },
+  "preconstruct": {
+    "entrypoints": [
+      "index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nixxiecms/nixxie/tree/main/packages/search"
+  }
+}

package/src/AlgoliaSearch.ts

@@ -0,0 +1,97 @@
+import type {
+  NixxieSearchDocument,
+  NixxieSearchQuery,
+  NixxieSearchResults,
+  NixxieSearchService,
+} from '@nixxie-cms/core'
+import type { AlgoliaConfig } from './types'
+
+/** Algolia backend over the REST API (no SDK dependency). */
+export class AlgoliaSearch implements NixxieSearchService {
+  private appId: string
+  private apiKey: string
+
+  constructor(config: AlgoliaConfig) {
+    this.appId = config.appId
+    this.apiKey = config.apiKey
+  }
+
+  private headers(): Record<string, string> {
+    return {
+      'Content-Type': 'application/json',
+      'X-Algolia-API-Key': this.apiKey,
+      'X-Algolia-Application-Id': this.appId,
+    }
+  }
+
+  private writeHost(): string {
+    return `https://${this.appId}.algolia.net`
+  }
+
+  private readHost(): string {
+    return `https://${this.appId}-dsn.algolia.net`
+  }
+
+  async index(
+    indexName: string,
+    documents: NixxieSearchDocument | NixxieSearchDocument[]
+  ): Promise<void> {
+    const docs = Array.isArray(documents) ? documents : [documents]
+    const requests = docs.map(d => ({ action: 'updateObject', body: { ...d, objectID: d.id } }))
+    const res = await fetch(`${this.writeHost()}/1/indexes/${indexName}/batch`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({ requests }),
+    })
+    if (!res.ok) throw new Error(`Algolia index failed (${res.status}): ${await res.text()}`)
+  }
+
+  async remove(indexName: string, id: string): Promise<void> {
+    await fetch(`${this.writeHost()}/1/indexes/${indexName}/${encodeURIComponent(id)}`, {
+      method: 'DELETE',
+      headers: this.headers(),
+    })
+  }
+
+  async search<T = NixxieSearchDocument>(
+    indexName: string,
+    query: NixxieSearchQuery
+  ): Promise<NixxieSearchResults<T>> {
+    const filters = query.filter
+      ? Object.entries(query.filter)
+          .map(([k, v]) => `${k}:${JSON.stringify(v)}`)
+          .join(' AND ')
+      : undefined
+    const res = await fetch(`${this.readHost()}/1/indexes/${indexName}/query`, {
+      method: 'POST',
+      headers: this.headers(),
+      // Algolia's two pagination modes are mutually exclusive: page+hitsPerPage OR offset+length.
+      // Mixing them returns HTTP 400, so use offset/length only.
+      body: JSON.stringify({
+        query: query.q,
+        offset: query.offset ?? 0,
+        length: query.limit ?? 20,
+        filters,
+      }),
+    })
+    if (!res.ok) throw new Error(`Algolia search failed (${res.status}): ${await res.text()}`)
+    const data = await res.json()
+    return {
+      hits: (data.hits ?? []).map((h: any) => ({
+        document: { ...h, id: h.objectID } as T,
+        score: h._rankingInfo?.userScore,
+      })),
+      total: data.nbHits ?? data.hits?.length ?? 0,
+      tookMs: data.processingTimeMS,
+    }
+  }
+
+  async clear(indexName: string): Promise<void> {
+    await fetch(`${this.writeHost()}/1/indexes/${indexName}/clear`, {
+      method: 'POST',
+      headers: this.headers(),
+    })
+  }
+
+  async close(): Promise<void> {}
+}

package/src/ElasticsearchSearch.ts

@@ -0,0 +1,96 @@
+import type {
+  NixxieSearchDocument,
+  NixxieSearchQuery,
+  NixxieSearchResults,
+  NixxieSearchService,
+} from '@nixxie-cms/core'
+import type { ElasticsearchConfig } from './types'
+
+/** Elasticsearch backend over the REST API (no SDK dependency). */
+export class ElasticsearchSearch implements NixxieSearchService {
+  private node: string
+  private authHeader?: string
+
+  constructor(config: ElasticsearchConfig) {
+    this.node = config.node.replace(/\/$/, '')
+    if (config.apiKey) this.authHeader = `ApiKey ${config.apiKey}`
+    else if (config.username && config.password) {
+      this.authHeader = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`
+    }
+  }
+
+  private async request(path: string, method: string, body?: unknown): Promise<any> {
+    const res = await fetch(`${this.node}${path}`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.authHeader ? { Authorization: this.authHeader } : {}),
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    })
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`Elasticsearch request failed (${res.status}): ${await res.text()}`)
+    }
+    return res.status === 404 ? undefined : res.json()
+  }
+
+  async index(
+    indexName: string,
+    documents: NixxieSearchDocument | NixxieSearchDocument[]
+  ): Promise<void> {
+    const docs = Array.isArray(documents) ? documents : [documents]
+    const body =
+      docs
+        .map(d => `${JSON.stringify({ index: { _index: indexName, _id: d.id } })}\n${JSON.stringify(d)}`)
+        .join('\n') + '\n'
+    const res = await fetch(`${this.node}/_bulk?refresh=true`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-ndjson',
+        ...(this.authHeader ? { Authorization: this.authHeader } : {}),
+      },
+      body,
+    })
+    if (!res.ok) throw new Error(`Elasticsearch bulk failed (${res.status}): ${await res.text()}`)
+  }
+
+  async remove(indexName: string, id: string): Promise<void> {
+    await this.request(`/${indexName}/_doc/${encodeURIComponent(id)}?refresh=true`, 'DELETE')
+  }
+
+  async search<T = NixxieSearchDocument>(
+    indexName: string,
+    query: NixxieSearchQuery
+  ): Promise<NixxieSearchResults<T>> {
+    const must: unknown[] = [
+      query.q ? { multi_match: { query: query.q, fields: ['*'] } } : { match_all: {} },
+    ]
+    const filter = query.filter
+      ? Object.entries(query.filter).map(([k, v]) => ({ term: { [k]: v } }))
+      : []
+    const sort = query.sort?.map(s => {
+      const [field, dir = 'asc'] = s.split(':')
+      return { [field]: dir }
+    })
+    const res = await this.request(`/${indexName}/_search`, 'POST', {
+      from: query.offset ?? 0,
+      size: query.limit ?? 20,
+      query: { bool: { must, filter } },
+      sort,
+    })
+    const hits = res?.hits?.hits ?? []
+    return {
+      hits: hits.map((h: any) => ({ document: { ...h._source, id: h._id } as T, score: h._score })),
+      total: typeof res?.hits?.total === 'object' ? res.hits.total.value : (res?.hits?.total ?? 0),
+      tookMs: res?.took,
+    }
+  }
+
+  async clear(indexName: string): Promise<void> {
+    await this.request(`/${indexName}/_delete_by_query?refresh=true`, 'POST', {
+      query: { match_all: {} },
+    })
+  }
+
+  async close(): Promise<void> {}
+}