@verdaccio/search 7.0.0-next.0 → 7.0.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @verdaccio/proxy
 
+## 7.0.0-next.2
+
+### Major Changes
+
+- e7ebccb61: update major dependencies, remove old nodejs support
+
+### Minor Changes
+
+- daceb6d87: restore legacy support
+
+## 7.0.0-next.1
+
+### Patch Changes
+
+- 35cc57b79: fix: keyword undefined errors
+
 ## 7.0.0-next.0
 
 ### Major Changes

package/build/dist.js

@@ -786,7 +786,7 @@ __export(src_exports, {
   SearchMemoryIndexer: () => indexer_default
 });
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/languages.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/tokenizer/languages.js
 var STEMMERS = {
   arabic: "ar",
   armenian: "am",
@@ -849,12 +849,22 @@ var SPLITTERS = {
 };
 var SUPPORTED_LANGUAGES = Object.keys(STEMMERS);
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/utils.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/utils.js
 var baseId = Date.now().toString().slice(5);
 var lastId = 0;
 var nano = BigInt(1e3);
 var milli = BigInt(1e6);
 var second = BigInt(1e9);
+var MAX_ARGUMENT_FOR_STACK = 65535;
+function safeArrayPush(arr, newArr) {
+  if (newArr.length < MAX_ARGUMENT_FOR_STACK) {
+    Array.prototype.push.apply(arr, newArr);
+  } else {
+    for (let i = 0; i < newArr.length; i += MAX_ARGUMENT_FOR_STACK) {
+      Array.prototype.push.apply(arr, newArr.slice(i, i + MAX_ARGUMENT_FOR_STACK));
+    }
+  }
+}
 function sprintf(template, ...args) {
   return template.replace(/%(?:(?<position>\d+)\$)?(?<width>-?\d*\.?\d*)(?<type>[dfs])/g, function(...replaceArgs) {
     const groups = replaceArgs[replaceArgs.length - 1];
@@ -983,7 +993,7 @@ async function getNested(obj, path) {
   return props[path];
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/errors.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/errors.js
 var allLanguages = SUPPORTED_LANGUAGES.join("\n - ");
 var errors = {
   NO_LANGUAGE_WITH_CUSTOM_TOKENIZER: "Do not pass the language option to create when using a custom tokenizer.",
@@ -1012,7 +1022,12 @@ Supported languages are:
   SORT_DISABLED: `Sort is disabled. Please read the documentation at https://docs.oramasearch for more information.`,
   UNKNOWN_GROUP_BY_PROPERTY: `Unknown groupBy property "%s".`,
   INVALID_GROUP_BY_PROPERTY: `Invalid groupBy property "%s". Allowed types: "%s", but given "%s".`,
-  UNKNOWN_FILTER_PROPERTY: `Unknown filter property "%s".`
+  UNKNOWN_FILTER_PROPERTY: `Unknown filter property "%s".`,
+  INVALID_VECTOR_SIZE: `Vector size must be a number greater than 0. Got "%s" instead.`,
+  INVALID_VECTOR_VALUE: `Vector value must be a number greater than 0. Got "%s" instead.`,
+  INVALID_INPUT_VECTOR: `Property "%s" was declared as a %s-dimentional vector, but got a %s-dimentional vector instead.
+Input vectors must be of the size declared in the schema, as calculating similarity between vectors of different sizes can lead to unexpected results.`,
+  WRONG_SEARCH_PROPERTY_TYPE: `Property "%s" is not searchable. Only "string" properties are searchable.`
 };
 function createError(code, ...args) {
   var _a2;
@@ -1024,7 +1039,7 @@ function createError(code, ...args) {
   return error;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/defaults.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/defaults.js
 async function formatElapsedTime(n) {
   return {
     raw: Number(n),
@@ -1047,7 +1062,17 @@ async function validateSchema(doc, schema) {
     if (typeOfValue === "undefined") {
       continue;
     }
+    if (type === "enum" && (typeOfValue === "string" || typeOfValue === "number")) {
+      continue;
+    }
     const typeOfType = typeof type;
+    if (isVectorType(type)) {
+      const vectorSize = getVectorSize(type);
+      if (!Array.isArray(value) || value.length !== vectorSize) {
+        throw createError("INVALID_INPUT_VECTOR", prop, vectorSize, value.length);
+      }
+      continue;
+    }
     if (typeOfType === "string" && isArrayType(type)) {
       if (!Array.isArray(value)) {
         return prop;
@@ -1081,6 +1106,7 @@ var IS_ARRAY_TYPE = {
   string: false,
   number: false,
   boolean: false,
+  enum: false,
   "string[]": true,
   "number[]": true,
   "boolean[]": true
@@ -1090,14 +1116,28 @@ var INNER_TYPE = {
   "number[]": "number",
   "boolean[]": "boolean"
 };
+function isVectorType(type) {
+  return /^vector\[\d+\]$/.test(type);
+}
 function isArrayType(type) {
   return IS_ARRAY_TYPE[type];
 }
 function getInnerType(type) {
   return INNER_TYPE[type];
 }
+function getVectorSize(type) {
+  const size = Number(type.slice(7, -1));
+  switch (true) {
+    case isNaN(size):
+      throw createError("INVALID_VECTOR_VALUE", type);
+    case size <= 0:
+      throw createError("INVALID_VECTOR_SIZE", type);
+    default:
+      return size;
+  }
+}
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/internal-document-id-store.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/internal-document-id-store.js
 function createInternalDocumentIDStore() {
   return {
     idToInternalId: /* @__PURE__ */ new Map(),
@@ -1143,7 +1183,7 @@ function getDocumentIdFromInternalId(store2, internalId) {
   return store2.internalIdToId[internalId - 1];
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/documents-store.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/documents-store.js
 async function create(_, sharedInternalDocumentStore) {
   return {
     sharedInternalDocumentStore,
@@ -1217,7 +1257,7 @@ async function createDocumentsStore() {
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/hooks.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/hooks.js
 var OBJECT_COMPONENTS = [
   "tokenizer",
   "index",
@@ -1258,7 +1298,7 @@ async function runAfterSearch(hooks, db, params, language, results) {
   }
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/trees/avl.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/trees/avl.js
 var BALANCE_STATE = {
   UNBALANCED_RIGHT: -2,
   SLIGHTLY_UNBALANCED_RIGHT: -1,
@@ -1298,7 +1338,7 @@ function rangeSearch(node, min, max) {
       traverse(node2.left);
     }
     if (node2.key >= min && node2.key <= max) {
-      result.push(...node2.value);
+      safeArrayPush(result, node2.value);
     }
     if (node2.key < max) {
       traverse(node2.right);
@@ -1317,10 +1357,10 @@ function greaterThan(node, key, inclusive = false) {
       return;
     }
     if (inclusive && node2.key >= key) {
-      result.push(...node2.value);
+      safeArrayPush(result, node2.value);
     }
     if (!inclusive && node2.key > key) {
-      result.push(...node2.value);
+      safeArrayPush(result, node2.value);
     }
     traverse(node2.left);
     traverse(node2.right);
@@ -1338,10 +1378,10 @@ function lessThan(node, key, inclusive = false) {
       return;
     }
     if (inclusive && node2.key <= key) {
-      result.push(...node2.value);
+      safeArrayPush(result, node2.value);
     }
     if (!inclusive && node2.key < key) {
-      result.push(...node2.value);
+      safeArrayPush(result, node2.value);
     }
     traverse(node2.left);
     traverse(node2.right);
@@ -1491,6 +1531,9 @@ function remove2(root, key) {
 }
 function removeDocument(root, id, key) {
   const node = getNodeByKey(root, key);
+  if (!node) {
+    return;
+  }
   if (node.value.length === 1) {
     remove2(root, key);
     return;
@@ -1498,7 +1541,7 @@ function removeDocument(root, id, key) {
   node.value.splice(node.value.indexOf(id), 1);
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/levenshtein.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/levenshtein.js
 function _boundedLevenshtein(a, b, tolerance) {
   if (a === b) {
     return 0;
@@ -1587,7 +1630,7 @@ function syncBoundedLevenshtein(a, b, tolerance) {
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/trees/radix.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/trees/radix.js
 var Node = class {
   constructor(key, subWord, end) {
     this.key = key;
@@ -1765,7 +1808,73 @@ function removeDocumentByWord(root, term, docID, exact = true) {
   return true;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/algorithms.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/trees/flat.js
+function create4() {
+  return {
+    numberToDocumentId: /* @__PURE__ */ new Map()
+  };
+}
+function insert3(root, key, value) {
+  if (root.numberToDocumentId.has(key)) {
+    root.numberToDocumentId.get(key).push(value);
+    return root;
+  }
+  root.numberToDocumentId.set(key, [
+    value
+  ]);
+  return root;
+}
+function removeDocument3(root, id, key) {
+  var _a2;
+  var _root_numberToDocumentId_get, _root_numberToDocumentId_get1;
+  root === null || root === void 0 ? void 0 : root.numberToDocumentId.set(key, (_a2 = (_root_numberToDocumentId_get = root === null || root === void 0 ? void 0 : root.numberToDocumentId.get(key)) === null || _root_numberToDocumentId_get === void 0 ? void 0 : _root_numberToDocumentId_get.filter((v2) => v2 !== id)) != null ? _a2 : []);
+  if (((_root_numberToDocumentId_get1 = root === null || root === void 0 ? void 0 : root.numberToDocumentId.get(key)) === null || _root_numberToDocumentId_get1 === void 0 ? void 0 : _root_numberToDocumentId_get1.length) === 0) {
+    root === null || root === void 0 ? void 0 : root.numberToDocumentId.delete(key);
+  }
+}
+function filter(root, operation) {
+  var _a2;
+  const operationKeys = Object.keys(operation);
+  if (operationKeys.length !== 1) {
+    throw new Error("Invalid operation");
+  }
+  const operationType = operationKeys[0];
+  switch (operationType) {
+    case "eq": {
+      const value = operation[operationType];
+      return (_a2 = root.numberToDocumentId.get(value)) != null ? _a2 : [];
+    }
+    case "in": {
+      const value = operation[operationType];
+      const result = [];
+      for (const v2 of value) {
+        const ids = root.numberToDocumentId.get(v2);
+        if (ids) {
+          result.push(...ids);
+        }
+      }
+      return result;
+    }
+    case "nin": {
+      const value = operation[operationType];
+      const result = [];
+      const keys = root.numberToDocumentId.keys();
+      for (const key of keys) {
+        if (value.includes(key)) {
+          continue;
+        }
+        const ids = root.numberToDocumentId.get(key);
+        if (ids) {
+          result.push(...ids);
+        }
+      }
+      return result;
+    }
+  }
+  throw new Error("Invalid operation");
+}
+
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/algorithms.js
 function prioritizeTokenScores(arrays, boost, threshold = 1, keywordsCount) {
   if (boost === 0) {
     throw createError("INVALID_BOOST_VALUE");
@@ -1829,7 +1938,16 @@ function BM25(tf, matchingCount, docsCount, fieldLength, averageFieldLength, BM2
   return idf * (d + tf * (k + 1)) / (tf + k * (1 - b + b * fieldLength / averageFieldLength));
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/index.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/cosine-similarity.js
+function getMagnitude(vector, vectorLength) {
+  let magnitude = 0;
+  for (let i = 0; i < vectorLength; i++) {
+    magnitude += vector[i] * vector[i];
+  }
+  return Math.sqrt(magnitude);
+}
+
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/index.js
 async function insertDocumentScoreParameters(index, prop, id, tokens, docsCount) {
   var _a2;
   const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
@@ -1884,11 +2002,12 @@ async function calculateResultScores(context, index, prop, term, ids) {
   }
   return scoreList;
 }
-async function create4(orama, sharedInternalDocumentStore, schema, index, prefix = "") {
+async function create5(orama, sharedInternalDocumentStore, schema, index, prefix = "") {
   if (!index) {
     index = {
       sharedInternalDocumentStore,
       indexes: {},
+      vectorIndexes: {},
       searchableProperties: [],
       searchablePropertiesWithTypes: {},
       frequencies: {},
@@ -1901,62 +2020,93 @@ async function create4(orama, sharedInternalDocumentStore, schema, index, prefix
     const typeActualType = typeof type;
     const path = `${prefix}${prefix ? "." : ""}${prop}`;
     if (typeActualType === "object" && !Array.isArray(type)) {
-      create4(orama, sharedInternalDocumentStore, type, index, path);
+      create5(orama, sharedInternalDocumentStore, type, index, path);
       continue;
     }
-    switch (type) {
-      case "boolean":
-      case "boolean[]":
-        index.indexes[path] = {
-          true: [],
-          false: []
-        };
-        break;
-      case "number":
-      case "number[]":
-        index.indexes[path] = create2(0, []);
-        break;
-      case "string":
-      case "string[]":
-        index.indexes[path] = create3();
-        index.avgFieldLength[path] = 0;
-        index.frequencies[path] = {};
-        index.tokenOccurrences[path] = {};
-        index.fieldLengths[path] = {};
-        break;
-      default:
-        throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path);
+    if (isVectorType(type)) {
+      index.searchableProperties.push(path);
+      index.searchablePropertiesWithTypes[path] = type;
+      index.vectorIndexes[path] = {
+        size: getVectorSize(type),
+        vectors: {}
+      };
+    } else {
+      switch (type) {
+        case "boolean":
+        case "boolean[]":
+          index.indexes[path] = {
+            type: "Bool",
+            node: {
+              true: [],
+              false: []
+            }
+          };
+          break;
+        case "number":
+        case "number[]":
+          index.indexes[path] = {
+            type: "AVL",
+            node: create2(0, [])
+          };
+          break;
+        case "string":
+        case "string[]":
+          index.indexes[path] = {
+            type: "Radix",
+            node: create3()
+          };
+          index.avgFieldLength[path] = 0;
+          index.frequencies[path] = {};
+          index.tokenOccurrences[path] = {};
+          index.fieldLengths[path] = {};
+          break;
+        case "enum":
+          index.indexes[path] = {
+            type: "Flat",
+            node: create4()
+          };
+          break;
+        default:
+          throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path);
+      }
+      index.searchableProperties.push(path);
+      index.searchablePropertiesWithTypes[path] = type;
     }
-    index.searchableProperties.push(path);
-    index.searchablePropertiesWithTypes[path] = type;
   }
   return index;
 }
 async function insertScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
   const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
-  switch (schemaType) {
-    case "boolean": {
-      const booleanIndex = index.indexes[prop];
-      booleanIndex[value ? "true" : "false"].push(internalId);
+  const { type, node } = index.indexes[prop];
+  switch (type) {
+    case "Bool": {
+      node[value ? "true" : "false"].push(internalId);
       break;
     }
-    case "number":
-      insert(index.indexes[prop], value, [
+    case "AVL":
+      insert(node, value, [
         internalId
       ]);
       break;
-    case "string": {
+    case "Radix": {
       const tokens = await tokenizer.tokenize(value, language, prop);
       await implementation.insertDocumentScoreParameters(index, prop, internalId, tokens, docsCount);
       for (const token of tokens) {
         await implementation.insertTokenScoreParameters(index, prop, internalId, tokens, token);
-        insert2(index.indexes[prop], token, internalId);
+        insert2(node, token, internalId);
       }
       break;
     }
+    case "Flat": {
+      insert3(node, value, internalId);
+      break;
+    }
   }
 }
-async function insert3(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
+async function insert4(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
+  if (isVectorType(schemaType)) {
+    return insertVector(index, prop, value, id);
+  }
   if (!isArrayType(schemaType)) {
     return insertScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount);
   }
@@ -1967,28 +2117,44 @@ async function insert3(implementation, index, prop, id, value, schemaType, langu
     await insertScalar(implementation, index, prop, id, elements[i], innerSchemaType, language, tokenizer, docsCount);
   }
 }
+function insertVector(index, prop, value, id) {
+  if (!(value instanceof Float32Array)) {
+    value = new Float32Array(value);
+  }
+  const size = index.vectorIndexes[prop].size;
+  const magnitude = getMagnitude(value, size);
+  index.vectorIndexes[prop].vectors[id] = [
+    magnitude,
+    value
+  ];
+}
 async function removeScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
   const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
-  switch (schemaType) {
-    case "number": {
-      removeDocument(index.indexes[prop], internalId, value);
+  const { type, node } = index.indexes[prop];
+  switch (type) {
+    case "AVL": {
+      removeDocument(node, internalId, value);
       return true;
     }
-    case "boolean": {
+    case "Bool": {
       const booleanKey = value ? "true" : "false";
-      const position = index.indexes[prop][booleanKey].indexOf(internalId);
-      index.indexes[prop][value ? "true" : "false"].splice(position, 1);
+      const position = node[booleanKey].indexOf(internalId);
+      node[value ? "true" : "false"].splice(position, 1);
       return true;
     }
-    case "string": {
+    case "Radix": {
       const tokens = await tokenizer.tokenize(value, language, prop);
       await implementation.removeDocumentScoreParameters(index, prop, id, docsCount);
       for (const token of tokens) {
         await implementation.removeTokenScoreParameters(index, prop, token);
-        removeDocumentByWord(index.indexes[prop], token, internalId);
+        removeDocumentByWord(node, token, internalId);
       }
       return true;
     }
+    case "Flat": {
+      removeDocument3(node, internalId, value);
+      return true;
+    }
   }
 }
 async function remove3(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
@@ -2007,9 +2173,12 @@ async function search(context, index, prop, term) {
   if (!(prop in index.tokenOccurrences)) {
     return [];
   }
-  const rootNode = index.indexes[prop];
+  const { node, type } = index.indexes[prop];
+  if (type !== "Radix") {
+    throw createError("WRONG_SEARCH_PROPERTY_TYPE", prop);
+  }
   const { exact, tolerance } = context.params;
-  const searchResult = find2(rootNode, {
+  const searchResult = find2(node, {
     term,
     exact,
     tolerance
@@ -2030,29 +2199,28 @@ async function searchByWhereClause(context, index, filters) {
   }, acc), {});
   for (const param of filterKeys) {
     const operation = filters[param];
-    if (typeof operation === "boolean") {
-      const idx = index.indexes[param];
-      if (typeof idx === "undefined") {
-        throw createError("UNKNOWN_FILTER_PROPERTY", param);
-      }
+    if (typeof index.indexes[param] === "undefined") {
+      throw createError("UNKNOWN_FILTER_PROPERTY", param);
+    }
+    const { node, type } = index.indexes[param];
+    if (type === "Bool") {
+      const idx = node;
       const filteredIDs = idx[operation.toString()];
-      filtersMap[param].push(...filteredIDs);
+      safeArrayPush(filtersMap[param], filteredIDs);
       continue;
     }
-    if (typeof operation === "string" || Array.isArray(operation)) {
-      const idx = index.indexes[param];
-      if (typeof idx === "undefined") {
-        throw createError("UNKNOWN_FILTER_PROPERTY", param);
-      }
+    if (type === "Radix" && (typeof operation === "string" || Array.isArray(operation))) {
       for (const raw of [
         operation
       ].flat()) {
         const term = await context.tokenizer.tokenize(raw, context.language, param);
-        const filteredIDsResults = find2(idx, {
-          term: term[0],
-          exact: true
-        });
-        filtersMap[param].push(...Object.values(filteredIDsResults).flat());
+        for (const t of term) {
+          const filteredIDsResults = find2(node, {
+            term: t,
+            exact: true
+          });
+          safeArrayPush(filtersMap[param], Object.values(filteredIDsResults).flat());
+        }
       }
       continue;
     }
@@ -2060,43 +2228,42 @@ async function searchByWhereClause(context, index, filters) {
     if (operationKeys.length > 1) {
       throw createError("INVALID_FILTER_OPERATION", operationKeys.length);
     }
-    const operationOpt = operationKeys[0];
-    const operationValue = operation[operationOpt];
-    const AVLNode = index.indexes[param];
-    if (typeof AVLNode === "undefined") {
-      throw createError("UNKNOWN_FILTER_PROPERTY", param);
+    if (type === "Flat") {
+      filtersMap[param].push(...filter(node, operation));
+      continue;
     }
-    switch (operationOpt) {
-      case "gt": {
-        const filteredIDs = greaterThan(AVLNode, operationValue, false);
-        filtersMap[param].push(...filteredIDs);
-        break;
-      }
-      case "gte": {
-        const filteredIDs = greaterThan(AVLNode, operationValue, true);
-        filtersMap[param].push(...filteredIDs);
-        break;
-      }
-      case "lt": {
-        const filteredIDs = lessThan(AVLNode, operationValue, false);
-        filtersMap[param].push(...filteredIDs);
-        break;
-      }
-      case "lte": {
-        const filteredIDs = lessThan(AVLNode, operationValue, true);
-        filtersMap[param].push(...filteredIDs);
-        break;
-      }
-      case "eq": {
-        const filteredIDs = (_a2 = find(AVLNode, operationValue)) != null ? _a2 : [];
-        filtersMap[param].push(...filteredIDs);
-        break;
-      }
-      case "between": {
-        const [min, max] = operationValue;
-        const filteredIDs = rangeSearch(AVLNode, min, max);
-        filtersMap[param].push(...filteredIDs);
+    if (type === "AVL") {
+      const operationOpt = operationKeys[0];
+      const operationValue = operation[operationOpt];
+      let filteredIDs = [];
+      switch (operationOpt) {
+        case "gt": {
+          filteredIDs = greaterThan(node, operationValue, false);
+          break;
+        }
+        case "gte": {
+          filteredIDs = greaterThan(node, operationValue, true);
+          break;
+        }
+        case "lt": {
+          filteredIDs = lessThan(node, operationValue, false);
+          break;
+        }
+        case "lte": {
+          filteredIDs = lessThan(node, operationValue, true);
+          break;
+        }
+        case "eq": {
+          filteredIDs = (_a2 = find(node, operationValue)) != null ? _a2 : [];
+          break;
+        }
+        case "between": {
+          const [min, max] = operationValue;
+          filteredIDs = rangeSearch(node, min, max);
+          break;
+        }
       }
+      safeArrayPush(filtersMap[param], filteredIDs);
     }
   }
   const result = intersect(Object.values(filtersMap));
@@ -2108,29 +2275,63 @@ async function getSearchableProperties(index) {
 async function getSearchablePropertiesWithTypes(index) {
   return index.searchablePropertiesWithTypes;
 }
-function loadNode(node) {
+function loadRadixNode(node) {
   const convertedNode = create3(node.end, node.subWord, node.key);
   convertedNode.docs = node.docs;
   convertedNode.word = node.word;
   for (const childrenKey of Object.keys(node.children)) {
-    convertedNode.children[childrenKey] = loadNode(node.children[childrenKey]);
+    convertedNode.children[childrenKey] = loadRadixNode(node.children[childrenKey]);
   }
   return convertedNode;
 }
+function loadFlatNode(node) {
+  return {
+    numberToDocumentId: new Map(node)
+  };
+}
+function saveFlatNode(node) {
+  return Array.from(node.numberToDocumentId.entries());
+}
 async function load3(sharedInternalDocumentStore, raw) {
-  const { indexes: rawIndexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrences, avgFieldLength, fieldLengths } = raw;
+  const { indexes: rawIndexes, vectorIndexes: rawVectorIndexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrences, avgFieldLength, fieldLengths } = raw;
   const indexes = {};
+  const vectorIndexes = {};
   for (const prop of Object.keys(rawIndexes)) {
-    const value = rawIndexes[prop];
-    if (!("word" in value)) {
-      indexes[prop] = value;
-      continue;
+    const { node, type } = rawIndexes[prop];
+    switch (type) {
+      case "Radix":
+        indexes[prop] = {
+          type: "Radix",
+          node: loadRadixNode(node)
+        };
+        break;
+      case "Flat":
+        indexes[prop] = {
+          type: "Flat",
+          node: loadFlatNode(node)
+        };
+        break;
+      default:
+        indexes[prop] = rawIndexes[prop];
     }
-    indexes[prop] = loadNode(value);
+  }
+  for (const idx of Object.keys(rawVectorIndexes)) {
+    const vectors = rawVectorIndexes[idx].vectors;
+    for (const vec in vectors) {
+      vectors[vec] = [
+        vectors[vec][0],
+        new Float32Array(vectors[vec][1])
+      ];
+    }
+    vectorIndexes[idx] = {
+      size: rawVectorIndexes[idx].size,
+      vectors
+    };
   }
   return {
     sharedInternalDocumentStore,
     indexes,
+    vectorIndexes,
     searchableProperties,
     searchablePropertiesWithTypes,
     frequencies,
@@ -2140,9 +2341,36 @@ async function load3(sharedInternalDocumentStore, raw) {
   };
 }
 async function save3(index) {
-  const { indexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrences, avgFieldLength, fieldLengths } = index;
+  const { indexes, vectorIndexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrences, avgFieldLength, fieldLengths } = index;
+  const vectorIndexesAsArrays = {};
+  for (const idx of Object.keys(vectorIndexes)) {
+    const vectors = vectorIndexes[idx].vectors;
+    for (const vec in vectors) {
+      vectors[vec] = [
+        vectors[vec][0],
+        Array.from(vectors[vec][1])
+      ];
+    }
+    vectorIndexesAsArrays[idx] = {
+      size: vectorIndexes[idx].size,
+      vectors
+    };
+  }
+  const savedIndexes = {};
+  for (const name of Object.keys(indexes)) {
+    const { type, node } = indexes[name];
+    if (type !== "Flat") {
+      savedIndexes[name] = indexes[name];
+      continue;
+    }
+    savedIndexes[name] = {
+      type: "Flat",
+      node: saveFlatNode(node)
+    };
+  }
   return {
-    indexes,
+    indexes: savedIndexes,
+    vectorIndexes: vectorIndexesAsArrays,
     searchableProperties,
     searchablePropertiesWithTypes,
     frequencies,
@@ -2153,8 +2381,8 @@ async function save3(index) {
 }
 async function createIndex() {
   return {
-    create: create4,
-    insert: insert3,
+    create: create5,
+    insert: insert4,
     remove: remove3,
     insertDocumentScoreParameters,
     insertTokenScoreParameters,
@@ -2170,7 +2398,7 @@ async function createIndex() {
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/diacritics.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/tokenizer/diacritics.js
 var DIACRITICS_CHARCODE_START = 192;
 var DIACRITICS_CHARCODE_END = 383;
 var CHARCODE_REPLACE_MAPPING = [
@@ -2380,7 +2608,7 @@ function replaceDiacritics(str) {
   return String.fromCharCode(...stringCharCode);
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/english-stemmer.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/tokenizer/english-stemmer.js
 var step2List = {
   ational: "ate",
   tional: "tion",
@@ -2540,7 +2768,7 @@ function stemmer(w) {
   return w;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/index.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/tokenizer/index.js
 function normalizeToken(prop, token) {
   var _this_stopWords;
   const key = `${this.language}:${prop}:${token}`;
@@ -2576,8 +2804,15 @@ function tokenize(input, language, prop) {
       input
     ];
   }
-  const splitRule = SPLITTERS[this.language];
-  const tokens = input.toLowerCase().split(splitRule).map(this.normalizeToken.bind(this, prop != null ? prop : "")).filter(Boolean);
+  let tokens;
+  if (prop && this.tokenizeSkipProperties.has(prop)) {
+    tokens = [
+      this.normalizeToken.bind(this, prop != null ? prop : "")(input)
+    ];
+  } else {
+    const splitRule = SPLITTERS[this.language];
+    tokens = input.toLowerCase().split(splitRule).map(this.normalizeToken.bind(this, prop != null ? prop : "")).filter(Boolean);
+  }
   const trimTokens = trim(tokens);
   if (!this.allowDuplicates) {
     return Array.from(new Set(trimTokens));
@@ -2631,6 +2866,9 @@ async function createTokenizer(config = {}) {
     stemmerSkipProperties: new Set(config.stemmerSkipProperties ? [
       config.stemmerSkipProperties
     ].flat() : []),
+    tokenizeSkipProperties: new Set(config.tokenizeSkipProperties ? [
+      config.tokenizeSkipProperties
+    ].flat() : []),
     stopWords,
     allowDuplicates: Boolean(config.allowDuplicates),
     normalizeToken,
@@ -2641,7 +2879,7 @@ async function createTokenizer(config = {}) {
   return tokenizer;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/sorter.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/sorter.js
 function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedProperties, prefix) {
   const sorter = {
     language: orama.tokenizer.language,
@@ -2665,30 +2903,33 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
       sorter.sortablePropertiesWithTypes = __spreadValues(__spreadValues({}, sorter.sortablePropertiesWithTypes), ret.sortablePropertiesWithTypes);
       continue;
     }
-    switch (type) {
-      case "boolean":
-      case "number":
-      case "string":
-        sorter.sortableProperties.push(path);
-        sorter.sortablePropertiesWithTypes[path] = type;
-        sorter.sorts[path] = {
-          docs: /* @__PURE__ */ new Map(),
-          orderedDocsToRemove: /* @__PURE__ */ new Map(),
-          orderedDocs: [],
-          type
-        };
-        break;
-      case "boolean[]":
-      case "number[]":
-      case "string[]":
-        continue;
-      default:
-        throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path);
+    if (!isVectorType(type)) {
+      switch (type) {
+        case "boolean":
+        case "number":
+        case "string":
+          sorter.sortableProperties.push(path);
+          sorter.sortablePropertiesWithTypes[path] = type;
+          sorter.sorts[path] = {
+            docs: /* @__PURE__ */ new Map(),
+            orderedDocsToRemove: /* @__PURE__ */ new Map(),
+            orderedDocs: [],
+            type
+          };
+          break;
+        case "enum":
+        case "boolean[]":
+        case "number[]":
+        case "string[]":
+          continue;
+        default:
+          throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path);
+      }
     }
   }
   return sorter;
 }
-async function create5(orama, sharedInternalDocumentStore, schema, config) {
+async function create6(orama, sharedInternalDocumentStore, schema, config) {
   const isSortEnabled = (config === null || config === void 0 ? void 0 : config.enabled) !== false;
   if (!isSortEnabled) {
     return {
@@ -2697,7 +2938,7 @@ async function create5(orama, sharedInternalDocumentStore, schema, config) {
   }
   return innerCreate(orama, sharedInternalDocumentStore, schema, (config || {}).unsortableProperties || [], "");
 }
-async function insert4(sorter, prop, id, value) {
+async function insert5(sorter, prop, id, value) {
   if (!sorter.enabled) {
     return;
   }
@@ -2878,8 +3119,8 @@ async function save4(sorter) {
 }
 async function createSorter() {
   return {
-    create: create5,
-    insert: insert4,
+    create: create6,
+    insert: insert5,
     remove: remove4,
     save: save4,
     load: load4,
@@ -2889,7 +3130,7 @@ async function createSorter() {
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/create.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/methods/create.js
 function validateComponents(components) {
   const defaultComponents = {
     formatElapsedTime,
@@ -2929,7 +3170,7 @@ function validateComponents(components) {
     }
   }
 }
-async function create6({ schema, sort, language, components, id }) {
+async function create7({ schema, sort, language, components, id }) {
   if (!components) {
     components = {};
   }
@@ -2992,11 +3233,11 @@ async function create6({ schema, sort, language, components, id }) {
   return orama;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/types.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/types.js
 var kInsertions = Symbol("orama.insertions");
 var kRemovals = Symbol("orama.removals");
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/sync-blocking-checker.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/sync-blocking-checker.js
 var _globalThis_process;
 var _a;
 var warn = (_a = (_globalThis_process = globalThis.process) === null || _globalThis_process === void 0 ? void 0 : _globalThis_process.emitWarning) != null ? _a : function emitWarning(message, options) {
@@ -3035,8 +3276,8 @@ function trackRemoval(orama) {
   }
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/insert.js
-async function insert5(orama, doc, language, skipHooks) {
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/methods/insert.js
+async function insert6(orama, doc, language, skipHooks) {
   const errorProperty = await orama.validateSchema(doc, orama.schema);
   if (errorProperty) {
     throw createError("SCHEMA_VALIDATION_FAILURE", errorProperty);
@@ -3065,9 +3306,15 @@ async function innerInsert(orama, doc, language, skipHooks) {
     }
     const actualType = typeof value;
     const expectedType = indexablePropertiesWithTypes[key];
+    if (isVectorType(expectedType) && Array.isArray(value)) {
+      continue;
+    }
     if (isArrayType(expectedType) && Array.isArray(value)) {
       continue;
     }
+    if (expectedType === "enum" && (actualType === "string" || actualType === "number")) {
+      continue;
+    }
     if (actualType !== expectedType) {
       throw createError("INVALID_DOCUMENT_PROPERTY", key, expectedType, actualType);
     }
@@ -3101,7 +3348,7 @@ async function innerInsert(orama, doc, language, skipHooks) {
   return id;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/remove.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/methods/remove.js
 async function remove5(orama, id, language, skipHooks) {
   let result = true;
   const { index, docs } = orama.data;
@@ -3146,7 +3393,7 @@ async function remove5(orama, id, language, skipHooks) {
   return result;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/facets.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/facets.js
 function sortingPredicate(order = "desc", a, b) {
   if (order.toLowerCase() === "asc") {
     return a[1] - b[1];
@@ -3255,7 +3502,7 @@ function calculateBooleanOrStringFacet(values, facetValue, propertyType, already
   }
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/filters.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/filters.js
 function intersectFilteredIDs(filtered, lookedUp) {
   const map = /* @__PURE__ */ new Map();
   const result = [];
@@ -3274,7 +3521,7 @@ function intersectFilteredIDs(filtered, lookedUp) {
   return result;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/groups.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/components/groups.js
 var DEFAULT_REDUCE = {
   reducer: (_, acc, res, index) => {
     acc[index] = res;
@@ -3395,16 +3642,17 @@ function calculateCombination(arrs, index = 0) {
   const combinations = [];
   for (const value of head) {
     for (const combination of c2) {
-      combinations.push([
-        value,
-        ...combination
-      ]);
+      const result = [
+        value
+      ];
+      safeArrayPush(result, combination);
+      combinations.push(result);
     }
   }
   return combinations;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/search.js
+// ../../node_modules/.pnpm/@orama+orama@1.2.4/node_modules/@orama/orama/dist/methods/search.js
 var defaultBM25Params = {
   k: 1.2,
   b: 0.75,
@@ -3474,7 +3722,7 @@ async function search2(orama, params, language) {
       for (let j = 0; j < tokensLength2; j++) {
         const term2 = tokens[j];
         const scoreList = await orama.index.search(context, index, prop, term2);
-        context.indexMap[prop][term2].push(...scoreList);
+        safeArrayPush(context.indexMap[prop][term2], scoreList);
       }
       const docIds = context.indexMap[prop];
       const vals = Object.values(docIds);
@@ -3628,6 +3876,7 @@ var debug = (0, import_debug.default)("verdaccio:search:indexer");
 var SearchMemoryIndexer = class {
   database;
   storage;
+  logger;
   configureStorage(storage) {
     this.storage = storage;
   }
@@ -3635,24 +3884,32 @@ var SearchMemoryIndexer = class {
     if (this.database) {
       debug("searching %s at indexer", term);
       const searchResult = await search2(this.database, {
-        term,
-        properties: "*"
+        term
       });
       return searchResult;
     }
   }
+  prepareKeywords(keywords) {
+    if (typeof keywords === "undefined") {
+      return "";
+    } else if (typeof keywords === "string") {
+      return keywords;
+    }
+    return keywords.join(",");
+  }
   async add(pkg) {
     if (this.database) {
       const name = pkg.name;
       debug("adding item %s to the indexer", name);
-      insert5(this.database, {
+      const item = {
         id: name,
         name,
         description: pkg.description,
-        version: `v${pkg.version}`,
-        keywords: pkg.keywords,
-        author: pkg._npmUser ? pkg._npmUser.name : "???"
-      });
+        version: pkg.version,
+        keywords: this.prepareKeywords(pkg.keywords),
+        author: pkg._npmUser ? pkg._npmUser.name : ""
+      };
+      await insert6(this.database, item);
     }
   }
   async remove(name) {
@@ -3661,10 +3918,11 @@ var SearchMemoryIndexer = class {
       await remove5(this.database, name);
     }
   }
-  reindex() {
+  async reindex() {
     var _a2;
     debug("reindexing search indexer");
-    (_a2 = this.storage) == null ? void 0 : _a2.getLocalDatabase((error, packages) => {
+    (_a2 = this.storage) == null ? void 0 : _a2.getLocalDatabase(async (error, packages) => {
+      var _a3;
       if (error) {
         throw error;
       }
@@ -3675,13 +3933,18 @@ var SearchMemoryIndexer = class {
       while (i--) {
         const pkg = packages[i];
         debug("indexing package %s", pkg == null ? void 0 : pkg.name);
-        this.add(pkg);
+        try {
+          await this.add(pkg);
+        } catch (err) {
+          (_a3 = this.logger) == null ? void 0 : _a3.error({ err: err.message }, "error @{err} indexing package");
+        }
       }
       debug("reindexed search indexer");
     });
   }
-  async init() {
-    this.database = await create6({
+  async init(logger) {
+    this.logger = logger;
+    this.database = await create7({
       schema: {
         id: "string",
         name: "string",

package/build/indexer.d.ts

@@ -1,8 +1,9 @@
-import { Version } from '@verdaccio/types';
+import { Logger, Version } from '@verdaccio/types';
 type Results = any;
 declare class SearchMemoryIndexer {
     private database;
     private storage;
+    private logger;
     /**
      * Set up the {Storage}
      * @param {*} storage An storage reference.
@@ -16,6 +17,7 @@ declare class SearchMemoryIndexer {
      * @return {Array} list of results.
      */
     query(term: string): Promise<Results | void>;
+    private prepareKeywords;
     /**
      * Add a new element to index
      * @param {*} pkg the package
@@ -29,8 +31,8 @@ declare class SearchMemoryIndexer {
     /**
      * Force a re-index.
      */
-    reindex(): void;
-    init(): Promise<void>;
+    reindex(): Promise<void>;
+    init(logger: Logger): Promise<void>;
 }
 declare const _default: SearchMemoryIndexer;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdaccio/search",
-  "version": "7.0.0-next.0",
+  "version": "7.0.0-next.2",
   "description": "verdaccio search utitlity tools",
   "main": "./build/dist.js",
   "types": "build/index.d.ts",
@@ -26,12 +26,11 @@
     "verdaccio"
   ],
   "engines": {
-    "node": ">=12",
-    "npm": ">=6"
+    "node": ">=12"
   },
   "devDependencies": {
-    "@verdaccio/types": "12.0.0-next.0",
-    "@orama/orama": "1.1.1",
+    "@verdaccio/types": "12.0.0-next.1",
+    "@orama/orama": "1.2.4",
     "debug": "4.3.4",
     "esbuild": "0.14.10"
   },
@@ -41,7 +40,7 @@
   },
   "scripts": {
     "clean": "rimraf ./build",
-    "test": "echo 1",
+    "test": "vitest run",
     "type-check": "tsc --noEmit -p tsconfig.build.json",
     "build:types": "tsc --emitDeclarationOnly -p tsconfig.build.json",
     "build:js": "babel src/ --out-dir build/ --copy-files --extensions \".ts,.tsx\" --source-maps",

package/src/indexer.ts

@@ -1,7 +1,7 @@
 import { create, insert, remove, search } from '@orama/orama';
 import buildDebug from 'debug';
 
-import { Version } from '@verdaccio/types';
+import { Logger, Version } from '@verdaccio/types';
 
 const debug = buildDebug('verdaccio:search:indexer');
 
@@ -10,6 +10,7 @@ type Results = any;
 class SearchMemoryIndexer {
   private database: any | undefined;
   private storage: any;
+  private logger: Logger | undefined;
 
   /**
    * Set up the {Storage}
@@ -31,13 +32,21 @@ class SearchMemoryIndexer {
       debug('searching %s at indexer', term);
       const searchResult = await search(this.database, {
         term,
-        properties: '*',
       });
 
       return searchResult;
     }
   }
 
+  private prepareKeywords(keywords?: string[] | string): string {
+    if (typeof keywords === 'undefined') {
+      return '';
+    } else if (typeof keywords === 'string') {
+      return keywords;
+    }
+    return keywords.join(',');
+  }
+
   /**
    * Add a new element to index
    * @param {*} pkg the package
@@ -46,14 +55,15 @@ class SearchMemoryIndexer {
     if (this.database) {
       const name = pkg.name;
       debug('adding item %s to the indexer', name);
-      insert(this.database, {
+      const item = {
         id: name,
         name: name,
         description: pkg.description,
-        version: `v${pkg.version}`,
-        keywords: pkg.keywords,
-        author: pkg._npmUser ? pkg._npmUser.name : '???',
-      });
+        version: pkg.version,
+        keywords: this.prepareKeywords(pkg.keywords),
+        author: pkg._npmUser ? pkg._npmUser.name : '',
+      };
+      await insert(this.database, item);
     }
   }
 
@@ -71,9 +81,9 @@ class SearchMemoryIndexer {
   /**
    * Force a re-index.
    */
-  public reindex(): void {
+  public async reindex(): Promise<void> {
     debug('reindexing search indexer');
-    this.storage?.getLocalDatabase((error, packages): void => {
+    this.storage?.getLocalDatabase(async (error, packages): Promise<void> => {
       if (error) {
         // that function shouldn't produce any
         throw error;
@@ -86,13 +96,18 @@ class SearchMemoryIndexer {
       while (i--) {
         const pkg = packages[i];
         debug('indexing package %s', pkg?.name);
-        this.add(pkg);
+        try {
+          await this.add(pkg);
+        } catch (err: any) {
+          this.logger?.error({ err: err.message }, 'error @{err} indexing package');
+        }
       }
       debug('reindexed search indexer');
     });
   }
 
-  public async init() {
+  public async init(logger: Logger) {
+    this.logger = logger;
     this.database = await create({
       schema: {
         id: 'string',

package/test/index.spec.ts

@@ -0,0 +1,47 @@
+import { expect, test } from 'vitest';
+
+import { Logger } from '@verdaccio/types';
+
+import { SearchMemoryIndexer } from '../src';
+
+class MockStore {
+  getLocalDatabase(cb) {
+    return cb(null, [
+      {
+        name: 'verdaccio-search',
+        version: '1.0.0',
+        readme: 'foo',
+        description: 'foo',
+        keywords: ['foo', 'bar'],
+      },
+      {
+        name: 'verdaccio-utils',
+        version: '2.0.0',
+        readme: 'foo',
+        description: 'foo',
+        keywords: 'some',
+      },
+    ]);
+  }
+}
+
+const logger = {
+  // eslint-disable-next-line no-console
+  error: (...arg) => console.error(...arg),
+} as Logger;
+
+test('should search', async () => {
+  const store = new MockStore();
+
+  SearchMemoryIndexer.configureStorage(store);
+  await SearchMemoryIndexer.init(logger);
+  // @ts-expect-error
+  await SearchMemoryIndexer.add({
+    name: 'verdaccio',
+    version: '2.0.0',
+    readme: 'foo',
+    description: '',
+  });
+  const query = await SearchMemoryIndexer.query('verdaccio');
+  expect(query.hits.map((item) => item.id)).toEqual(['verdaccio', 'verdaccio-utils']);
+});