@usereactify/search 5.60.0-beta.0 → 5.60.0-beta.2

package/dist/src/search-request-builder/base-builders.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBaseSearchRequest = generateBaseSearchRequest;
+exports.generateCollectionSearchRequest = generateCollectionSearchRequest;
+exports.generateCollectionBaseQuery = generateCollectionBaseQuery;
+exports.generateWeightedSearchQuery = generateWeightedSearchQuery;
+exports.generateWeightedCollectionQuery = generateWeightedCollectionQuery;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+// Base Search Request Generation
+function generateBaseSearchRequest(options) {
+    var _a, _b, _c, _d;
+    if ((0, types_1.isCollectionOptions)(options)) {
+        // Collection search mode
+        const markets = (_b = (_a = options.curation) === null || _a === void 0 ? void 0 : _a.markets) !== null && _b !== void 0 ? _b : [];
+        return generateCollectionSearchRequest({
+            collectionHandle: options.collectionHandle,
+            markets: markets,
+        });
+    }
+    if ((0, types_1.isSearchOptions)(options)) {
+        // Term search mode
+        const markets = (_d = (_c = options.curation) === null || _c === void 0 ? void 0 : _c.markets) !== null && _d !== void 0 ? _d : [];
+        return generateTermSearchRequest({
+            searchTerm: options.searchTerm,
+            baseSearchRequestMode: options.baseSearchRequestMode,
+            relevanceFields: options.relevanceFields,
+            searchableFields: options.searchableFields,
+            markets: markets,
+        });
+    }
+    throw new Error("Invalid options: must be either search or collection options");
+}
+// Term Search Request Generation
+function generateTermSearchRequest(options) {
+    (0, utils_1.validateSearchInputs)(options);
+    if (options.baseSearchRequestMode === types_1.BaseSearchRequestMode.Weighted) {
+        return generateWeightedTermSearchRequest(options);
+    }
+    return generateRelevanceTermSearchRequest(options);
+}
+function generateWeightedTermSearchRequest(options) {
+    if (!options.searchableFields) {
+        throw new Error("SearchableFields required for weighted search");
+    }
+    const functionScoreQuery = generateWeightedSearchQuery({
+        searchTerm: options.searchTerm,
+        searchableFields: options.searchableFields,
+        boostingRules: [],
+        markets: options.markets,
+    });
+    return { query: { function_score: functionScoreQuery } };
+}
+function generateRelevanceTermSearchRequest(options) {
+    const fieldMappings = (0, utils_1.prepareRelevanceFields)(options.relevanceFields);
+    const multiMatchQueries = (0, utils_1.generateMultiMatchQueries)(options.searchTerm, fieldMappings);
+    const query = buildRelevanceQueryStructure(multiMatchQueries, options.markets);
+    return { query };
+}
+function buildRelevanceQueryStructure(multiMatchQueries, markets) {
+    return {
+        bool: {
+            must: [{ bool: { should: multiMatchQueries, minimum_should_match: "1" } }],
+            filter: (0, utils_1.generateMarketsFilter)(markets),
+        },
+    };
+}
+// Collection Search Request Generation
+function generateCollectionSearchRequest(options) {
+    const query = generateCollectionBaseQuery(options);
+    return { query };
+}
+function generateCollectionBaseQuery(options) {
+    const mustClauses = [
+        {
+            nested: {
+                path: "collections",
+                query: {
+                    term: { ["collections.handle"]: options.collectionHandle },
+                },
+            },
+        },
+    ];
+    const marketClause = (0, utils_1.generateMarketsFilter)(options.markets);
+    if (marketClause.length > 0) {
+        mustClauses.push(...marketClause);
+    }
+    return { bool: { must: mustClauses } };
+}
+// Weighted Search Implementation - using corrected property names
+function generateWeightedSearchQuery(options) {
+    var _a, _b;
+    const searchTerms = (_b = (_a = options.searchTerm) === null || _a === void 0 ? void 0 : _a.split(" ")) !== null && _b !== void 0 ? _b : [];
+    const searchQueries = [];
+    for (const searchableField of options.searchableFields) {
+        const baseField = searchableField.field;
+        const maxEdits = searchableField.maxEdits;
+        for (const searchTerm of searchTerms) {
+            searchQueries.push({
+                match: { [baseField]: { query: searchTerm, fuzziness: maxEdits, analyzer: "regular_analyzer" } },
+            });
+            if (searchableField.synonymEnabled) {
+                searchQueries.push({
+                    match: { [baseField]: { query: searchTerm, fuzziness: maxEdits, analyzer: "synonym_analyzer" } },
+                });
+            }
+        }
+    }
+    const searchScores = [];
+    for (const field of options.searchableFields) {
+        const baseField = field.field;
+        const maxPoints = field.points;
+        const maxEdits = field.maxEdits;
+        for (let edits = 0; edits <= maxEdits; edits++) {
+            const weightMaxEdits = Math.max(maxPoints - maxEdits * (maxPoints / (100 / field.mistakePenaltyPercent)), 0);
+            const weightSomeEdits = maxPoints / (100 / field.mistakePenaltyPercent);
+            const weightBase = edits === maxEdits ? weightMaxEdits : weightSomeEdits;
+            for (const searchTerm of searchTerms) {
+                searchScores.push({
+                    filter: {
+                        match: { [baseField]: { query: searchTerm, fuzziness: edits, analyzer: "regular_analyzer" } },
+                    },
+                    weight: weightBase,
+                });
+                if (field.synonymEnabled && field.synonymPenaltyPercent > 0) {
+                    const weightSynonyms = weightBase * (1 - field.synonymPenaltyPercent / 100);
+                    searchScores.push({
+                        filter: {
+                            bool: {
+                                must_not: {
+                                    match: { [baseField]: { query: searchTerm, fuzziness: edits, analyzer: "regular_analyzer" } },
+                                },
+                                must: {
+                                    match: { [baseField]: { query: searchTerm, fuzziness: edits, analyzer: "synonym_analyzer" } },
+                                },
+                            },
+                        },
+                        weight: weightSynonyms,
+                    });
+                }
+            }
+        }
+    }
+    const marketClause = (0, utils_1.generateMarketsClause)(options.markets);
+    const boolQuery = { should: [...searchQueries] };
+    if (marketClause) {
+        boolQuery.filter = [marketClause];
+    }
+    return {
+        query: {
+            bool: boolQuery,
+        },
+        functions: [
+            ...searchScores,
+            ...(0, utils_1.generateBoostingRules)({ boostingRules: options.boostingRules, market: options.market }),
+        ],
+        score_mode: "sum",
+        boost_mode: "replace",
+    };
+}
+function generateWeightedCollectionQuery(options) {
+    const mustClauses = [
+        {
+            nested: {
+                path: "collections",
+                query: {
+                    term: { ["collections.handle"]: options.collectionHandle },
+                },
+            },
+        },
+    ];
+    const marketClause = (0, utils_1.generateMarketsClause)(options.markets);
+    if (marketClause)
+        mustClauses.push(marketClause);
+    return {
+        query: {
+            bool: { must: mustClauses },
+        },
+        functions: (0, utils_1.generateBoostingRules)({ boostingRules: options.boostingRules, market: options.market }),
+        score_mode: "sum",
+        boost_mode: "replace",
+    };
+}
+//# sourceMappingURL=base-builders.js.map

package/dist/src/search-request-builder/base-builders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-builders.js","sourceRoot":"","sources":["../../../src/search-request-builder/base-builders.ts"],"names":[],"mappings":"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","sourcesContent":["import { Boosting, SearchableField } from \"../types/firestore\";\nimport {\n  BaseSearchRequestMode,\n  FunctionScoreContainer,\n  FunctionScoreQuery,\n  GenerateSearchRequestOptions,\n  QueryContainer,\n  SearchRequest,\n  TermSearchRequestOptions,\n  CollectionSearchRequestOptions,\n  isSearchOptions,\n  isCollectionOptions,\n} from \"./types\";\nimport {\n  generateBoostingRules,\n  generateMarketsClause,\n  generateMarketsFilter,\n  generateMultiMatchQueries,\n  prepareRelevanceFields,\n  validateSearchInputs,\n} from \"./utils\";\n\n// Base Search Request Generation\nexport function generateBaseSearchRequest(options: GenerateSearchRequestOptions): SearchRequest {\n  if (isCollectionOptions(options)) {\n    // Collection search mode\n    const markets = options.curation?.markets ?? [];\n    return generateCollectionSearchRequest({\n      collectionHandle: options.collectionHandle,\n      markets: markets,\n    });\n  }\n\n  if (isSearchOptions(options)) {\n    // Term search mode\n    const markets = options.curation?.markets ?? [];\n    return generateTermSearchRequest({\n      searchTerm: options.searchTerm,\n      baseSearchRequestMode: options.baseSearchRequestMode,\n      relevanceFields: options.relevanceFields,\n      searchableFields: options.searchableFields,\n      markets: markets,\n    });\n  }\n\n  throw new Error(\"Invalid options: must be either search or collection options\");\n}\n\n// Term Search Request Generation\nfunction generateTermSearchRequest(options: TermSearchRequestOptions): SearchRequest {\n  validateSearchInputs(options);\n\n  if (options.baseSearchRequestMode === BaseSearchRequestMode.Weighted) {\n    return generateWeightedTermSearchRequest(options);\n  }\n\n  return generateRelevanceTermSearchRequest(options);\n}\n\nfunction generateWeightedTermSearchRequest(options: TermSearchRequestOptions): SearchRequest {\n  if (!options.searchableFields) {\n    throw new Error(\"SearchableFields required for weighted search\");\n  }\n\n  const functionScoreQuery = generateWeightedSearchQuery({\n    searchTerm: options.searchTerm,\n    searchableFields: options.searchableFields,\n    boostingRules: [],\n    markets: options.markets,\n  });\n\n  return { query: { function_score: functionScoreQuery } };\n}\n\nfunction generateRelevanceTermSearchRequest(options: TermSearchRequestOptions): SearchRequest {\n  const fieldMappings = prepareRelevanceFields(options.relevanceFields);\n  const multiMatchQueries = generateMultiMatchQueries(options.searchTerm, fieldMappings);\n  const query = buildRelevanceQueryStructure(multiMatchQueries, options.markets);\n  return { query };\n}\n\nfunction buildRelevanceQueryStructure(multiMatchQueries: QueryContainer[], markets: string[]): QueryContainer {\n  return {\n    bool: {\n      must: [{ bool: { should: multiMatchQueries, minimum_should_match: \"1\" } }],\n      filter: generateMarketsFilter(markets),\n    },\n  };\n}\n\n// Collection Search Request Generation\nexport function generateCollectionSearchRequest(options: CollectionSearchRequestOptions): SearchRequest {\n  const query = generateCollectionBaseQuery(options);\n  return { query };\n}\n\nexport function generateCollectionBaseQuery(options: CollectionSearchRequestOptions): QueryContainer {\n  const mustClauses: QueryContainer[] = [\n    {\n      nested: {\n        path: \"collections\",\n        query: {\n          term: { [\"collections.handle\"]: options.collectionHandle },\n        },\n      },\n    },\n  ];\n\n  const marketClause = generateMarketsFilter(options.markets);\n  if (marketClause.length > 0) {\n    mustClauses.push(...marketClause);\n  }\n\n  return { bool: { must: mustClauses } };\n}\n\n// Weighted Search Implementation - using corrected property names\nexport function generateWeightedSearchQuery(options: {\n  searchTerm: string;\n  searchableFields: SearchableField[];\n  boostingRules: Boosting[];\n  markets: string[];\n  market?: string;\n}): FunctionScoreQuery {\n  const searchTerms = options.searchTerm?.split(\" \") ?? [];\n\n  const searchQueries: QueryContainer[] = [];\n  for (const searchableField of options.searchableFields) {\n    const baseField = searchableField.field;\n    const maxEdits = searchableField.maxEdits;\n    for (const searchTerm of searchTerms) {\n      searchQueries.push({\n        match: { [baseField]: { query: searchTerm, fuzziness: maxEdits, analyzer: \"regular_analyzer\" } },\n      });\n      if (searchableField.synonymEnabled) {\n        searchQueries.push({\n          match: { [baseField]: { query: searchTerm, fuzziness: maxEdits, analyzer: \"synonym_analyzer\" } },\n        });\n      }\n    }\n  }\n\n  const searchScores: FunctionScoreContainer[] = [];\n  for (const field of options.searchableFields) {\n    const baseField = field.field;\n    const maxPoints = field.points;\n    const maxEdits = field.maxEdits;\n\n    for (let edits = 0; edits <= maxEdits; edits++) {\n      const weightMaxEdits = Math.max(maxPoints - maxEdits * (maxPoints / (100 / field.mistakePenaltyPercent)), 0);\n      const weightSomeEdits = maxPoints / (100 / field.mistakePenaltyPercent);\n      const weightBase = edits === maxEdits ? weightMaxEdits : weightSomeEdits;\n\n      for (const searchTerm of searchTerms) {\n        searchScores.push({\n          filter: {\n            match: { [baseField]: { query: searchTerm, fuzziness: edits, analyzer: \"regular_analyzer\" } },\n          },\n          weight: weightBase,\n        });\n\n        if (field.synonymEnabled && field.synonymPenaltyPercent > 0) {\n          const weightSynonyms = weightBase * (1 - field.synonymPenaltyPercent / 100);\n\n          searchScores.push({\n            filter: {\n              bool: {\n                must_not: {\n                  match: { [baseField]: { query: searchTerm, fuzziness: edits, analyzer: \"regular_analyzer\" } },\n                },\n                must: {\n                  match: { [baseField]: { query: searchTerm, fuzziness: edits, analyzer: \"synonym_analyzer\" } },\n                },\n              },\n            },\n            weight: weightSynonyms,\n          });\n        }\n      }\n    }\n  }\n\n  const marketClause = generateMarketsClause(options.markets);\n  const boolQuery: any = { should: [...searchQueries] };\n\n  if (marketClause) {\n    boolQuery.filter = [marketClause];\n  }\n\n  return {\n    query: {\n      bool: boolQuery,\n    },\n    functions: [\n      ...searchScores,\n      ...generateBoostingRules({ boostingRules: options.boostingRules, market: options.market }),\n    ],\n    score_mode: \"sum\",\n    boost_mode: \"replace\",\n  };\n}\n\nexport function generateWeightedCollectionQuery(options: {\n  collectionHandle: string;\n  boostingRules: Boosting[];\n  markets: string[];\n  market?: string;\n}): FunctionScoreQuery {\n  const mustClauses: QueryContainer[] = [\n    {\n      nested: {\n        path: \"collections\",\n        query: {\n          term: { [\"collections.handle\"]: options.collectionHandle },\n        },\n      },\n    },\n  ];\n\n  const marketClause = generateMarketsClause(options.markets);\n  if (marketClause) mustClauses.push(marketClause);\n\n  return {\n    query: {\n      bool: { must: mustClauses },\n    },\n    functions: generateBoostingRules({ boostingRules: options.boostingRules, market: options.market }),\n    score_mode: \"sum\",\n    boost_mode: \"replace\",\n  };\n}\n"]}

package/dist/src/search-request-builder/curation-builders.d.ts

@@ -0,0 +1,2 @@
+import { GenerateSearchRequestOptions, SearchRequest } from "./types";
+export declare function generateCurationSearchRequest(options: GenerateSearchRequestOptions): Partial<SearchRequest>;

package/dist/src/search-request-builder/curation-builders.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCurationSearchRequest = generateCurationSearchRequest;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+function generateCurationSearchRequest(options) {
+    if (options.curationSearchRequestMode === types_1.CurationSearchRequestMode.Weighted) {
+        return generateWeightedCurationSearchRequest(options);
+    }
+    return generateBoostedCurationSearchRequest(options);
+}
+function generateWeightedCurationSearchRequest(options) {
+    const curationRules = extractCurationRules(options.curation);
+    return {
+        query: {
+            function_score: {
+                query: { match_all: {} }, // Add required query field
+                functions: curationRules.boostingRules
+                    .map((boostingRule) => (0, utils_1.generateBoostingRule)({ boostingRule, market: options.market }))
+                    .filter(Boolean),
+                score_mode: "sum",
+                boost_mode: "replace",
+            },
+        },
+    };
+}
+// This `sort` field is handled by SensorSort.
+// ReactiveSearch does not combine multiple top-level `sort` fields; a `SearchRequest` is limited to one.
+function generateBoostedCurationSearchRequest(options) {
+    return {};
+}
+// Supporting Functions
+function extractCurationRules(curation) {
+    var _a, _b, _c, _d, _e;
+    if (!curation) {
+        return { boostingRules: [], groupings: [], sortings: [] };
+    }
+    return {
+        boostingRules: (_a = curation.boostings) !== null && _a !== void 0 ? _a : [],
+        groupings: (_c = (_b = curation.boosting) === null || _b === void 0 ? void 0 : _b.groupings) !== null && _c !== void 0 ? _c : [],
+        sortings: (_e = (_d = curation.boosting) === null || _d === void 0 ? void 0 : _d.sortings) !== null && _e !== void 0 ? _e : [],
+    };
+}
+//# sourceMappingURL=curation-builders.js.map

package/dist/src/search-request-builder/curation-builders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curation-builders.js","sourceRoot":"","sources":["../../../src/search-request-builder/curation-builders.ts"],"names":[],"mappings":";;AAWA,sEAMC;AAjBD,mCAQiB;AACjB,mCAA+C;AAE/C,SAAgB,6BAA6B,CAAC,OAAqC;IACjF,IAAI,OAAO,CAAC,yBAAyB,KAAK,iCAAyB,CAAC,QAAQ,EAAE,CAAC;QAC7E,OAAO,qCAAqC,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED,OAAO,oCAAoC,CAAC,OAAO,CAAC,CAAC;AACvD,CAAC;AAED,SAAS,qCAAqC,CAAC,OAAqC;IAClF,MAAM,aAAa,GAAG,oBAAoB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE7D,OAAO;QACL,KAAK,EAAE;YACL,cAAc,EAAE;gBACd,KAAK,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,2BAA2B;gBACrD,SAAS,EAAE,aAAa,CAAC,aAAa;qBACnC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,IAAA,4BAAoB,EAAC,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;qBACrF,MAAM,CAAC,OAAO,CAAC;gBAClB,UAAU,EAAE,KAAK;gBACjB,UAAU,EAAE,SAAS;aACtB;SACF;KACF,CAAC;AACJ,CAAC;AAED,8CAA8C;AAC9C,yGAAyG;AACzG,SAAS,oCAAoC,CAAC,OAAqC;IACjF,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,uBAAuB;AACvB,SAAS,oBAAoB,CAAC,QAA8C;;IAC1E,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAC5D,CAAC;IAED,OAAO;QACL,aAAa,EAAE,MAAA,QAAQ,CAAC,SAAS,mCAAI,EAAE;QACvC,SAAS,EAAE,MAAA,MAAA,QAAQ,CAAC,QAAQ,0CAAE,SAAS,mCAAI,EAAE;QAC7C,QAAQ,EAAE,MAAA,MAAA,QAAQ,CAAC,QAAQ,0CAAE,QAAQ,mCAAI,EAAE;KAC5C,CAAC;AACJ,CAAC","sourcesContent":["import {\n  CurationRules,\n  CurationSearchRequestMode,\n  GenerateSearchRequestOptions,\n  SearchRequest,\n  SortOptions,\n  SearchCuration,\n  CollectionCuration,\n} from \"./types\";\nimport { generateBoostingRule } from \"./utils\";\n\nexport function generateCurationSearchRequest(options: GenerateSearchRequestOptions): Partial<SearchRequest> {\n  if (options.curationSearchRequestMode === CurationSearchRequestMode.Weighted) {\n    return generateWeightedCurationSearchRequest(options);\n  }\n\n  return generateBoostedCurationSearchRequest(options);\n}\n\nfunction generateWeightedCurationSearchRequest(options: GenerateSearchRequestOptions): Partial<SearchRequest> {\n  const curationRules = extractCurationRules(options.curation);\n\n  return {\n    query: {\n      function_score: {\n        query: { match_all: {} }, // Add required query field\n        functions: curationRules.boostingRules\n          .map((boostingRule) => generateBoostingRule({ boostingRule, market: options.market }))\n          .filter(Boolean),\n        score_mode: \"sum\",\n        boost_mode: \"replace\",\n      },\n    },\n  };\n}\n\n// This `sort` field is handled by SensorSort.\n// ReactiveSearch does not combine multiple top-level `sort` fields; a `SearchRequest` is limited to one.\nfunction generateBoostedCurationSearchRequest(options: GenerateSearchRequestOptions): Partial<SearchRequest> {\n  return {};\n}\n\n// Supporting Functions\nfunction extractCurationRules(curation?: SearchCuration | CollectionCuration): CurationRules {\n  if (!curation) {\n    return { boostingRules: [], groupings: [], sortings: [] };\n  }\n\n  return {\n    boostingRules: curation.boostings ?? [],\n    groupings: curation.boosting?.groupings ?? [],\n    sortings: curation.boosting?.sortings ?? [],\n  };\n}\n"]}

package/dist/src/search-request-builder/index.d.ts

@@ -0,0 +1,3 @@
+export { generateSearchRequest, determineSearchRequestModes } from "./search-request-builder";
+export type { SearchRequest, GenerateSearchRequestOptions, SearchRequestModes } from "./types";
+export { BaseSearchRequestMode, CurationSearchRequestMode } from "./types";

package/dist/src/search-request-builder/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurationSearchRequestMode = exports.BaseSearchRequestMode = exports.determineSearchRequestModes = exports.generateSearchRequest = void 0;
+// Main public API exports
+var search_request_builder_1 = require("./search-request-builder");
+Object.defineProperty(exports, "generateSearchRequest", { enumerable: true, get: function () { return search_request_builder_1.generateSearchRequest; } });
+Object.defineProperty(exports, "determineSearchRequestModes", { enumerable: true, get: function () { return search_request_builder_1.determineSearchRequestModes; } });
+// Runtime enums (can be used as values)
+var types_1 = require("./types");
+Object.defineProperty(exports, "BaseSearchRequestMode", { enumerable: true, get: function () { return types_1.BaseSearchRequestMode; } });
+Object.defineProperty(exports, "CurationSearchRequestMode", { enumerable: true, get: function () { return types_1.CurationSearchRequestMode; } });
+//# sourceMappingURL=index.js.map

package/dist/src/search-request-builder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/search-request-builder/index.ts"],"names":[],"mappings":";;;AAAA,0BAA0B;AAC1B,mEAA8F;AAArF,+HAAA,qBAAqB,OAAA;AAAE,qIAAA,2BAA2B,OAAA;AAK3D,wCAAwC;AACxC,iCAA2E;AAAlE,8GAAA,qBAAqB,OAAA;AAAE,kHAAA,yBAAyB,OAAA","sourcesContent":["// Main public API exports\nexport { generateSearchRequest, determineSearchRequestModes } from \"./search-request-builder\";\n\n// Types and enums (commonly used)\nexport type { SearchRequest, GenerateSearchRequestOptions, SearchRequestModes } from \"./types\";\n\n// Runtime enums (can be used as values)\nexport { BaseSearchRequestMode, CurationSearchRequestMode } from \"./types\";\n"]}

package/dist/src/search-request-builder/search-request-builder.d.ts

@@ -0,0 +1,3 @@
+import { GenerateSearchRequestOptions, SearchRequest, SearchRequestModes } from "./types";
+export declare function generateSearchRequest(options: GenerateSearchRequestOptions): SearchRequest;
+export declare function determineSearchRequestModes(flags: string[]): SearchRequestModes;

package/dist/src/search-request-builder/search-request-builder.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSearchRequest = generateSearchRequest;
+exports.determineSearchRequestModes = determineSearchRequestModes;
+const base_builders_1 = require("./base-builders");
+const curation_builders_1 = require("./curation-builders");
+const types_1 = require("./types");
+// Main Entry Point - Search Request Strategy Router
+function generateSearchRequest(options) {
+    const baseSearchRequest = (0, base_builders_1.generateBaseSearchRequest)(options);
+    // Only apply curation enhancements if curation exists
+    if (options.curation) {
+        const curationSearchRequest = (0, curation_builders_1.generateCurationSearchRequest)(options);
+        return combineSearchRequest(baseSearchRequest, curationSearchRequest);
+    }
+    return baseSearchRequest;
+}
+// Combine Search Request Function
+function combineSearchRequest(baseRequestSearch, curationSearchRequest) {
+    return Object.assign(Object.assign(Object.assign({}, baseRequestSearch), curationSearchRequest), (baseRequestSearch.query &&
+        curationSearchRequest.query && {
+        query: mergeQueries(baseRequestSearch.query, curationSearchRequest.query),
+    }));
+}
+function mergeQueries(baseQuery, enhancementQuery) {
+    if ("function_score" in enhancementQuery && enhancementQuery.function_score) {
+        return {
+            function_score: {
+                query: baseQuery,
+                functions: enhancementQuery.function_score.functions || [],
+                score_mode: enhancementQuery.function_score.score_mode,
+                boost_mode: enhancementQuery.function_score.boost_mode,
+            },
+        };
+    }
+    return enhancementQuery;
+}
+// Search Request Mode Detection Functions
+function determineSearchRequestModes(flags) {
+    const baseSearchRequestMode = detectBaseSearchRequestMode(flags);
+    const curationSearchRequestMode = detectCurationSearchRequestMode(flags);
+    return { baseSearchRequestMode, curationSearchRequestMode };
+}
+function detectBaseSearchRequestMode(flags) {
+    return (flags === null || flags === void 0 ? void 0 : flags.includes("use_weighted_base_search_request"))
+        ? types_1.BaseSearchRequestMode.Weighted
+        : types_1.BaseSearchRequestMode.Relevance;
+}
+function detectCurationSearchRequestMode(flags) {
+    return (flags === null || flags === void 0 ? void 0 : flags.includes("use_weighted_curation_search_request"))
+        ? types_1.CurationSearchRequestMode.Weighted
+        : types_1.CurationSearchRequestMode.Boosted;
+}
+//# sourceMappingURL=search-request-builder.js.map

package/dist/src/search-request-builder/search-request-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-request-builder.js","sourceRoot":"","sources":["../../../src/search-request-builder/search-request-builder.ts"],"names":[],"mappings":";;AAYA,sDAUC;AAiCD,kEAIC;AA3DD,mDAA4D;AAC5D,2DAAoE;AACpE,mCAOiB;AAEjB,oDAAoD;AACpD,SAAgB,qBAAqB,CAAC,OAAqC;IACzE,MAAM,iBAAiB,GAAG,IAAA,yCAAyB,EAAC,OAAO,CAAC,CAAC;IAE7D,sDAAsD;IACtD,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrB,MAAM,qBAAqB,GAAG,IAAA,iDAA6B,EAAC,OAAO,CAAC,CAAC;QACrE,OAAO,oBAAoB,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,CAAC;IACxE,CAAC;IAED,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED,kCAAkC;AAClC,SAAS,oBAAoB,CAC3B,iBAAgC,EAChC,qBAA6C;IAE7C,qDACK,iBAAiB,GACjB,qBAAqB,GACrB,CAAC,iBAAiB,CAAC,KAAK;QACzB,qBAAqB,CAAC,KAAK,IAAI;QAC7B,KAAK,EAAE,YAAY,CAAC,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,CAAC,KAAK,CAAC;KAC1E,CAAC,EACJ;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,SAAyB,EAAE,gBAAgC;IAC/E,IAAI,gBAAgB,IAAI,gBAAgB,IAAI,gBAAgB,CAAC,cAAc,EAAE,CAAC;QAC5E,OAAO;YACL,cAAc,EAAE;gBACd,KAAK,EAAE,SAAS;gBAChB,SAAS,EAAE,gBAAgB,CAAC,cAAc,CAAC,SAAS,IAAI,EAAE;gBAC1D,UAAU,EAAE,gBAAgB,CAAC,cAAc,CAAC,UAAU;gBACtD,UAAU,EAAE,gBAAgB,CAAC,cAAc,CAAC,UAAU;aACvD;SACF,CAAC;IACJ,CAAC;IAED,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED,0CAA0C;AAC1C,SAAgB,2BAA2B,CAAC,KAAe;IACzD,MAAM,qBAAqB,GAAG,2BAA2B,CAAC,KAAK,CAAC,CAAC;IACjE,MAAM,yBAAyB,GAAG,+BAA+B,CAAC,KAAK,CAAC,CAAC;IACzE,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,CAAC;AAC9D,CAAC;AAED,SAAS,2BAA2B,CAAC,KAAgB;IACnD,OAAO,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,QAAQ,CAAC,kCAAkC,CAAC;QACxD,CAAC,CAAC,6BAAqB,CAAC,QAAQ;QAChC,CAAC,CAAC,6BAAqB,CAAC,SAAS,CAAC;AACtC,CAAC;AAED,SAAS,+BAA+B,CAAC,KAAgB;IACvD,OAAO,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,QAAQ,CAAC,sCAAsC,CAAC;QAC5D,CAAC,CAAC,iCAAyB,CAAC,QAAQ;QACpC,CAAC,CAAC,iCAAyB,CAAC,OAAO,CAAC;AACxC,CAAC","sourcesContent":["import { generateBaseSearchRequest } from \"./base-builders\";\nimport { generateCurationSearchRequest } from \"./curation-builders\";\nimport {\n  BaseSearchRequestMode,\n  CurationSearchRequestMode,\n  GenerateSearchRequestOptions,\n  QueryContainer,\n  SearchRequest,\n  SearchRequestModes,\n} from \"./types\";\n\n// Main Entry Point - Search Request Strategy Router\nexport function generateSearchRequest(options: GenerateSearchRequestOptions): SearchRequest {\n  const baseSearchRequest = generateBaseSearchRequest(options);\n\n  // Only apply curation enhancements if curation exists\n  if (options.curation) {\n    const curationSearchRequest = generateCurationSearchRequest(options);\n    return combineSearchRequest(baseSearchRequest, curationSearchRequest);\n  }\n\n  return baseSearchRequest;\n}\n\n// Combine Search Request Function\nfunction combineSearchRequest(\n  baseRequestSearch: SearchRequest,\n  curationSearchRequest: Partial<SearchRequest>\n): SearchRequest {\n  return {\n    ...baseRequestSearch,\n    ...curationSearchRequest,\n    ...(baseRequestSearch.query &&\n      curationSearchRequest.query && {\n        query: mergeQueries(baseRequestSearch.query, curationSearchRequest.query),\n      }),\n  };\n}\n\nfunction mergeQueries(baseQuery: QueryContainer, enhancementQuery: QueryContainer): QueryContainer {\n  if (\"function_score\" in enhancementQuery && enhancementQuery.function_score) {\n    return {\n      function_score: {\n        query: baseQuery,\n        functions: enhancementQuery.function_score.functions || [],\n        score_mode: enhancementQuery.function_score.score_mode,\n        boost_mode: enhancementQuery.function_score.boost_mode,\n      },\n    };\n  }\n\n  return enhancementQuery;\n}\n\n// Search Request Mode Detection Functions\nexport function determineSearchRequestModes(flags: string[]): SearchRequestModes {\n  const baseSearchRequestMode = detectBaseSearchRequestMode(flags);\n  const curationSearchRequestMode = detectCurationSearchRequestMode(flags);\n  return { baseSearchRequestMode, curationSearchRequestMode };\n}\n\nfunction detectBaseSearchRequestMode(flags?: string[]): BaseSearchRequestMode {\n  return flags?.includes(\"use_weighted_base_search_request\")\n    ? BaseSearchRequestMode.Weighted\n    : BaseSearchRequestMode.Relevance;\n}\n\nfunction detectCurationSearchRequestMode(flags?: string[]): CurationSearchRequestMode {\n  return flags?.includes(\"use_weighted_curation_search_request\")\n    ? CurationSearchRequestMode.Weighted\n    : CurationSearchRequestMode.Boosted;\n}\n"]}

package/dist/src/search-request-builder/types.d.ts

@@ -0,0 +1,105 @@
+import { Boosting, BoostGrouping, BoostSorting, Curation, CurationType, Relevance, SearchableField } from "../types/firestore";
+export declare const BaseSearchRequestMode: {
+    readonly Relevance: "relevance";
+    readonly Weighted: "weighted";
+};
+export type BaseSearchRequestMode = typeof BaseSearchRequestMode[keyof typeof BaseSearchRequestMode];
+export declare const CurationSearchRequestMode: {
+    readonly Boosted: "boosted";
+    readonly Weighted: "weighted";
+};
+export type CurationSearchRequestMode = typeof CurationSearchRequestMode[keyof typeof CurationSearchRequestMode];
+export interface SearchRequestModes {
+    baseSearchRequestMode: BaseSearchRequestMode;
+    curationSearchRequestMode: CurationSearchRequestMode;
+}
+export interface GenerateSearchRequestBaseOptions {
+    relevanceFields?: Relevance[];
+    searchableFields?: SearchableField[];
+    market?: string;
+    baseSearchRequestMode: BaseSearchRequestMode;
+    curationSearchRequestMode: CurationSearchRequestMode;
+}
+export interface GenerateSearchRequestSearchOptions extends GenerateSearchRequestBaseOptions {
+    searchTerm: string;
+    curation?: SearchCuration;
+}
+export interface GenerateSearchRequestCollectionOptions extends GenerateSearchRequestBaseOptions {
+    collectionHandle: string;
+    curation?: CollectionCuration;
+}
+export type GenerateSearchRequestOptions = GenerateSearchRequestSearchOptions | GenerateSearchRequestCollectionOptions;
+export interface SearchCuration extends Curation {
+    type: CurationType.Search;
+    searchTerm: string;
+}
+export interface CollectionCuration extends Curation {
+    type: CurationType.Collection;
+    collectionHandle: string;
+}
+export interface CurationRules {
+    boostingRules: Boosting[];
+    groupings: BoostGrouping[];
+    sortings: BoostSorting[];
+}
+export interface TermSearchRequestOptions {
+    searchTerm: string;
+    baseSearchRequestMode: BaseSearchRequestMode;
+    relevanceFields?: Relevance[];
+    searchableFields?: SearchableField[];
+    markets: string[];
+}
+export interface CollectionSearchRequestOptions {
+    collectionHandle: string;
+    markets: string[];
+}
+export interface SearchRequest {
+    query?: QueryContainer;
+    sort?: SortOptions;
+}
+export interface QueryContainer {
+    bool?: BoolQuery;
+    function_score?: FunctionScoreQuery;
+    multi_match?: MultiMatchQuery;
+    match?: Record<string, any>;
+    match_all?: Record<string, any>;
+    term?: Record<string, any>;
+    terms?: Record<string, string[]>;
+    wildcard?: Record<string, string>;
+    range?: Record<string, any>;
+    nested?: NestedQuery;
+}
+export interface BoolQuery {
+    must?: QueryContainer | QueryContainer[];
+    should?: QueryContainer[];
+    must_not?: QueryContainer | QueryContainer[];
+    filter?: QueryContainer[];
+    minimum_should_match?: string | number;
+}
+export interface FunctionScoreQuery {
+    query: QueryContainer;
+    functions: FunctionScoreContainer[];
+    score_mode: FunctionScoreMode;
+    boost_mode: FunctionBoostMode;
+}
+export interface FunctionScoreContainer {
+    filter: QueryContainer;
+    weight: number;
+}
+export interface MultiMatchQuery {
+    query: string;
+    fields: string[];
+    type: "cross_fields" | "phrase" | "phrase_prefix";
+    operator: "and" | "or";
+}
+export interface NestedQuery {
+    path: string;
+    query: QueryContainer;
+}
+export type SortOptions = Record<string, any>[] | Record<string, any>;
+export type FunctionScoreMode = "sum" | "multiply" | "avg" | "max" | "min" | "first";
+export type FunctionBoostMode = "multiply" | "replace" | "sum" | "avg" | "max" | "min";
+export declare function isSearchOptions(options: GenerateSearchRequestOptions): options is GenerateSearchRequestSearchOptions;
+export declare function isCollectionOptions(options: GenerateSearchRequestOptions): options is GenerateSearchRequestCollectionOptions;
+export declare function isSearchCuration(curation?: Curation): curation is SearchCuration;
+export declare function isCollectionCuration(curation?: Curation): curation is CollectionCuration;

package/dist/src/search-request-builder/types.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurationSearchRequestMode = exports.BaseSearchRequestMode = void 0;
+exports.isSearchOptions = isSearchOptions;
+exports.isCollectionOptions = isCollectionOptions;
+exports.isSearchCuration = isSearchCuration;
+exports.isCollectionCuration = isCollectionCuration;
+const firestore_1 = require("../types/firestore");
+exports.BaseSearchRequestMode = {
+    Relevance: "relevance",
+    Weighted: "weighted",
+};
+exports.CurationSearchRequestMode = {
+    Boosted: "boosted",
+    Weighted: "weighted",
+};
+// Type guards for runtime type checking
+function isSearchOptions(options) {
+    return "searchTerm" in options;
+}
+function isCollectionOptions(options) {
+    return "collectionHandle" in options;
+}
+function isSearchCuration(curation) {
+    return (curation === null || curation === void 0 ? void 0 : curation.type) === firestore_1.CurationType.Search;
+}
+function isCollectionCuration(curation) {
+    return (curation === null || curation === void 0 ? void 0 : curation.type) === firestore_1.CurationType.Collection;
+}
+//# sourceMappingURL=types.js.map

package/dist/src/search-request-builder/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/search-request-builder/types.ts"],"names":[],"mappings":";;;AAwIA,0CAEC;AAED,kDAIC;AAED,4CAEC;AAED,oDAEC;AAxJD,kDAQ4B;AAEf,QAAA,qBAAqB,GAAG;IACnC,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,UAAU;CACZ,CAAC;AAGE,QAAA,yBAAyB,GAAG;IACvC,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;CACZ,CAAC;AAoHX,wCAAwC;AACxC,SAAgB,eAAe,CAAC,OAAqC;IACnE,OAAO,YAAY,IAAI,OAAO,CAAC;AACjC,CAAC;AAED,SAAgB,mBAAmB,CACjC,OAAqC;IAErC,OAAO,kBAAkB,IAAI,OAAO,CAAC;AACvC,CAAC;AAED,SAAgB,gBAAgB,CAAC,QAAmB;IAClD,OAAO,CAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,IAAI,MAAK,wBAAY,CAAC,MAAM,CAAC;AAChD,CAAC;AAED,SAAgB,oBAAoB,CAAC,QAAmB;IACtD,OAAO,CAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,IAAI,MAAK,wBAAY,CAAC,UAAU,CAAC;AACpD,CAAC","sourcesContent":["import {\n  Boosting,\n  BoostGrouping,\n  BoostSorting,\n  Curation,\n  CurationType,\n  Relevance,\n  SearchableField,\n} from \"../types/firestore\";\n\nexport const BaseSearchRequestMode = {\n  Relevance: \"relevance\",\n  Weighted: \"weighted\",\n} as const;\nexport type BaseSearchRequestMode = typeof BaseSearchRequestMode[keyof typeof BaseSearchRequestMode];\n\nexport const CurationSearchRequestMode = {\n  Boosted: \"boosted\",\n  Weighted: \"weighted\",\n} as const;\nexport type CurationSearchRequestMode = typeof CurationSearchRequestMode[keyof typeof CurationSearchRequestMode];\n\nexport interface SearchRequestModes {\n  baseSearchRequestMode: BaseSearchRequestMode;\n  curationSearchRequestMode: CurationSearchRequestMode;\n}\n\n// Base options shared by all search request types\nexport interface GenerateSearchRequestBaseOptions {\n  relevanceFields?: Relevance[];\n  searchableFields?: SearchableField[];\n  market?: string;\n  baseSearchRequestMode: BaseSearchRequestMode;\n  curationSearchRequestMode: CurationSearchRequestMode;\n}\n\n// Search-specific options\nexport interface GenerateSearchRequestSearchOptions extends GenerateSearchRequestBaseOptions {\n  searchTerm: string;\n  curation?: SearchCuration;\n}\n\n// Collection-specific options\nexport interface GenerateSearchRequestCollectionOptions extends GenerateSearchRequestBaseOptions {\n  collectionHandle: string;\n  curation?: CollectionCuration;\n}\n\n// Union type for the main interface\nexport type GenerateSearchRequestOptions = GenerateSearchRequestSearchOptions | GenerateSearchRequestCollectionOptions;\n\n// Refined curation types with better type safety\nexport interface SearchCuration extends Curation {\n  type: CurationType.Search;\n  searchTerm: string;\n}\n\nexport interface CollectionCuration extends Curation {\n  type: CurationType.Collection;\n  collectionHandle: string;\n}\n\nexport interface CurationRules {\n  boostingRules: Boosting[];\n  groupings: BoostGrouping[];\n  sortings: BoostSorting[];\n}\n\nexport interface TermSearchRequestOptions {\n  searchTerm: string;\n  baseSearchRequestMode: BaseSearchRequestMode;\n  relevanceFields?: Relevance[];\n  searchableFields?: SearchableField[];\n  markets: string[];\n}\n\nexport interface CollectionSearchRequestOptions {\n  collectionHandle: string;\n  markets: string[];\n}\n\n// Elasticsearch/OpenSearch type aliases - using basic types to avoid external dependency\nexport interface SearchRequest {\n  query?: QueryContainer;\n  sort?: SortOptions;\n}\n\nexport interface QueryContainer {\n  bool?: BoolQuery;\n  function_score?: FunctionScoreQuery;\n  multi_match?: MultiMatchQuery;\n  match?: Record<string, any>;\n  match_all?: Record<string, any>;\n  term?: Record<string, any>;\n  terms?: Record<string, string[]>;\n  wildcard?: Record<string, string>;\n  range?: Record<string, any>;\n  nested?: NestedQuery;\n}\n\nexport interface BoolQuery {\n  must?: QueryContainer | QueryContainer[];\n  should?: QueryContainer[];\n  must_not?: QueryContainer | QueryContainer[];\n  filter?: QueryContainer[];\n  minimum_should_match?: string | number;\n}\n\nexport interface FunctionScoreQuery {\n  query: QueryContainer;\n  functions: FunctionScoreContainer[];\n  score_mode: FunctionScoreMode;\n  boost_mode: FunctionBoostMode;\n}\n\nexport interface FunctionScoreContainer {\n  filter: QueryContainer;\n  weight: number;\n}\n\nexport interface MultiMatchQuery {\n  query: string;\n  fields: string[];\n  type: \"cross_fields\" | \"phrase\" | \"phrase_prefix\";\n  operator: \"and\" | \"or\";\n}\n\nexport interface NestedQuery {\n  path: string;\n  query: QueryContainer;\n}\n\nexport type SortOptions = Record<string, any>[] | Record<string, any>;\nexport type FunctionScoreMode = \"sum\" | \"multiply\" | \"avg\" | \"max\" | \"min\" | \"first\";\nexport type FunctionBoostMode = \"multiply\" | \"replace\" | \"sum\" | \"avg\" | \"max\" | \"min\";\n// Type guards for runtime type checking\nexport function isSearchOptions(options: GenerateSearchRequestOptions): options is GenerateSearchRequestSearchOptions {\n  return \"searchTerm\" in options;\n}\n\nexport function isCollectionOptions(\n  options: GenerateSearchRequestOptions\n): options is GenerateSearchRequestCollectionOptions {\n  return \"collectionHandle\" in options;\n}\n\nexport function isSearchCuration(curation?: Curation): curation is SearchCuration {\n  return curation?.type === CurationType.Search;\n}\n\nexport function isCollectionCuration(curation?: Curation): curation is CollectionCuration {\n  return curation?.type === CurationType.Collection;\n}\n"]}

package/dist/src/search-request-builder/utils.d.ts

@@ -0,0 +1,27 @@
+import { Boosting, Relevance } from "../types/firestore";
+import { FunctionScoreContainer, QueryContainer, TermSearchRequestOptions } from "./types";
+export declare function generateQueryField(options: {
+    fieldName: string;
+    market?: string;
+}): string;
+export declare function generateMarketsFilter(markets: string[]): QueryContainer[];
+export declare function generateMarketsClause(markets: string[]): QueryContainer | null;
+export declare function generateBoostingRule(options: {
+    boostingRule: Boosting;
+    market?: string;
+}): FunctionScoreContainer;
+export declare function generateBoostingRules(options: {
+    boostingRules: Boosting[];
+    market?: string;
+}): FunctionScoreContainer[];
+export declare function validateSearchInputs(options: TermSearchRequestOptions): void;
+export declare function prepareRelevanceFields(relevanceFields?: Relevance[]): {
+    crossFields: string[];
+    phrase: string[];
+    phrasePrefix: string[];
+};
+export declare function generateMultiMatchQueries(searchTerm: string, fieldMappings: {
+    crossFields: string[];
+    phrase: string[];
+    phrasePrefix: string[];
+}): QueryContainer[];