@nixxie-cms/search 1.0.1

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

@@ -0,0 +1,433 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/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}`);
+      }
+  }
+}
+
+exports.AlgoliaSearch = AlgoliaSearch;
+exports.ElasticsearchSearch = ElasticsearchSearch;
+exports.InMemorySearch = InMemorySearch;
+exports.MeilisearchSearch = MeilisearchSearch;
+exports.TypesenseSearch = TypesenseSearch;
+exports.createSearch = createSearch;