@resistdesign/voltra 3.0.0-alpha.14 → 3.0.0-alpha.15

package/api/index.js

@@ -3372,6 +3372,64 @@ async function structuredHandler(event) {
   }
 }
 
+// src/api/Indexing/structured/StructuredStringLike.ts
+var MAX_INDEXED_STRING_LENGTH = 128;
+var MAX_TOKENS_PER_VALUE = 256;
+var MAX_NGRAM_SIZE = 3;
+var LIKE_WILDCARD_REGEX = /[%_]/;
+var NORMALIZED_WHITESPACE_REGEX = /\s+/g;
+var STRUCTURED_STRING_CONTAINS_TOKEN_PREFIX = "__str__:";
+var normalizeStructuredLikeString = (value) => value.toLowerCase().trim().replace(NORMALIZED_WHITESPACE_REGEX, " ");
+var toNgrams = (normalized) => {
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  const limited = normalized.slice(0, MAX_INDEXED_STRING_LENGTH);
+  for (let size = 1; size <= MAX_NGRAM_SIZE; size += 1) {
+    if (limited.length < size) {
+      break;
+    }
+    for (let index = 0; index <= limited.length - size; index += 1) {
+      const token = limited.slice(index, index + size);
+      if (!seen.has(token)) {
+        seen.add(token);
+        tokens.push(token);
+        if (tokens.length >= MAX_TOKENS_PER_VALUE) {
+          return tokens;
+        }
+      }
+    }
+  }
+  return tokens;
+};
+var toContainsToken = (token) => `${STRUCTURED_STRING_CONTAINS_TOKEN_PREFIX}${token}`;
+var buildStructuredStringContainsTokens = (value) => {
+  const normalized = normalizeStructuredLikeString(value);
+  if (!normalized.length) {
+    return [];
+  }
+  return toNgrams(normalized).map(toContainsToken);
+};
+var buildStructuredLikePatternTokens = (value) => {
+  const normalized = normalizeStructuredLikeString(value);
+  const pattern = LIKE_WILDCARD_REGEX.test(normalized) ? normalized : `%${normalized}%`;
+  const literalSegments = pattern.split(LIKE_WILDCARD_REGEX).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const segment of literalSegments) {
+    for (const token of toNgrams(segment)) {
+      const containsToken = toContainsToken(token);
+      if (!seen.has(containsToken)) {
+        seen.add(containsToken);
+        tokens.push(containsToken);
+        if (tokens.length >= MAX_TOKENS_PER_VALUE) {
+          return tokens;
+        }
+      }
+    }
+  }
+  return tokens;
+};
+
 // src/api/Indexing/structured/StructuredInMemoryIndex.ts
 function insertSortedUnique2(values, docId) {
   let low = 0;
@@ -3515,6 +3573,11 @@ var StructuredInMemoryIndex = class {
         continue;
       }
       addPosting(this.eqIndex, field, value, docId);
+      if (typeof value === "string") {
+        for (const token of buildStructuredStringContainsTokens(value)) {
+          addPosting(this.containsIndex, field, token, docId);
+        }
+      }
       const entries = this.rangeIndex.get(field) ?? [];
       insertRangeEntry(entries, value, docId);
       this.rangeIndex.set(field, entries);
@@ -3758,6 +3821,11 @@ function buildTermEntries(docId, fields) {
       }
     } else {
       entries.push(buildStructuredTermItem(field, value, "eq", docId));
+      if (typeof value === "string") {
+        for (const token of buildStructuredStringContainsTokens(value)) {
+          entries.push(buildStructuredTermItem(field, token, "contains", docId));
+        }
+      }
     }
   }
   return entries;
@@ -7454,8 +7522,23 @@ var buildWhereForCriterion = (criterion) => {
     case "EQUALS" /* EQUALS */:
       return buildTerm(fieldName, "eq", value);
     case "CONTAINS" /* CONTAINS */:
-    case "LIKE" /* LIKE */:
       return buildTerm(fieldName, "contains", value);
+    case "LIKE" /* LIKE */: {
+      if (typeof value !== "string") {
+        return buildTerm(fieldName, "contains", value);
+      }
+      const tokens = buildStructuredLikePatternTokens(value);
+      const tokenClauses = tokens.map(
+        (token) => buildTerm(fieldName, "contains", token)
+      );
+      if (tokenClauses.length === 0) {
+        return buildTerm(fieldName, "contains", value);
+      }
+      if (tokenClauses.length === 1) {
+        return tokenClauses[0];
+      }
+      return { and: tokenClauses };
+    }
     case "GREATER_THAN_OR_EQUAL" /* GREATER_THAN_OR_EQUAL */:
       return { type: "gte", field: fieldName, value };
     case "LESS_THAN_OR_EQUAL" /* LESS_THAN_OR_EQUAL */:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resistdesign/voltra",
-  "version": "3.0.0-alpha.14",
+  "version": "3.0.0-alpha.15",
   "description": "With our powers combined!",
   "homepage": "https://voltra.app",
   "repository": "git@github.com:resistdesign/voltra.git",