2 files changed, 143 insertions, 1 deletions
diff --git a/src/lib/product/api/productSearchApi.js b/src/lib/product/api/productSearchApi.js
index a84caa3c..1a6ad36a 100644
--- a/src/lib/product/api/productSearchApi.js
+++ b/src/lib/product/api/productSearchApi.js
@@ -2,8 +2,37 @@ import _ from 'lodash-contrib';
 import axios from 'axios';
 
 const productSearchApi = async ({ query, operation = 'OR' }) => {
+  // Use POST for large product ID arrays to avoid URL length limits
+  // GET request URL limit is typically 2KB-8KB; switch to POST if query string is large
+  const QUERY_SIZE_THRESHOLD = 2000; // Switch to POST if query > 2KB
+
+  if (query.length > QUERY_SIZE_THRESHOLD) {
+    console.log(
+      `[productSearchApi] Large query (${query.length} chars), using POST`,
+    );
+
+    // Parse query string into object for POST body
+    const params = new URLSearchParams(query);
+    const bodyData = {
+      ...Object.fromEntries(params),
+      operation,
+    };
+
+    const dataProductSearch = await axios.post(
+      `${process.env.NEXT_PUBLIC_SELF_HOST}/api/shop/search`,
+      bodyData,
+      {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+    return dataProductSearch.data;
+  }
+
+  // Small query, use standard GET request
   const dataProductSearch = await axios(
-    `${process.env.NEXT_PUBLIC_SELF_HOST}/api/shop/search?${query}&operation=${operation}`
+    `${process.env.NEXT_PUBLIC_SELF_HOST}/api/shop/search?${query}&operation=${operation}`,
   );
   return dataProductSearch.data;
 };
diff --git a/src/lib/utils/batchSolrQueries.js b/src/lib/utils/batchSolrQueries.js
new file mode 100644
index 00000000..486f1778
--- /dev/null
+++ b/src/lib/utils/batchSolrQueries.js
@@ -0,0 +1,113 @@
+/**
+ * Batch utility functions for handling large product ID arrays in Solr queries
+ * Prevents URL length limit errors when querying with >100 product IDs
+ */
+
+/**
+ * Split an array into chunks of specified size
+ * @param {Array} array - Array to split
+ * @param {number} size - Chunk size (default: 100)
+ * @returns {Array<Array>} Array of chunks
+ */
+export const chunkArray = (array, size = 100) => {
+  if (!Array.isArray(array) || array.length === 0) return [];
+
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+};
+
+/**
+ * Build a product ID OR clause for Solr query
+ * @param {Array<string|number>} ids - Array of product IDs
+ * @returns {string} Formatted OR clause: "product_id_i:123 OR product_id_i:456..."
+ */
+export const buildProductIdOrClause = (ids) => {
+  if (!Array.isArray(ids) || ids.length === 0) {
+    return '*:*';
+  }
+  return ids.map((id) => `product_id_i:${id}`).join(' OR ');
+};
+
+/**
+ * Validate query size to prevent exceeding HTTP limits
+ * @param {string} query - Query string to validate
+ * @param {number} maxSize - Maximum allowed size in characters (default: 6000)
+ * @returns {Object} { valid: boolean, message: string, size: number }
+ */
+export const validateQuerySize = (query, maxSize = 6000) => {
+  const size = query.length;
+  return {
+    valid: size <= maxSize,
+    message:
+      size > maxSize
+        ? `Query size ${size} exceeds limit of ${maxSize}`
+        : `Query size ${size} is within limit`,
+    size,
+  };
+};
+
+/**
+ * Build batched Solr query parameters for large ID arrays
+ * Chunks IDs into groups and creates separate OR clauses
+ * @param {Array<string|number>} ids - Product IDs to query
+ * @param {number} chunkSize - How many IDs per chunk (default: 100)
+ * @returns {Array<string>} Array of OR clauses, one per chunk
+ */
+export const buildBatchedOrClauses = (ids, chunkSize = 100) => {
+  if (!Array.isArray(ids) || ids.length === 0) {
+    return ['*:*'];
+  }
+
+  const chunks = chunkArray(ids, chunkSize);
+
+  if (chunks.length === 1) {
+    // Single chunk, return standard OR clause
+    return [buildProductIdOrClause(ids)];
+  }
+
+  // Multiple chunks: return OR clauses wrapped with parentheses for combining
+  return chunks.map((chunk) => `(${buildProductIdOrClause(chunk)})`);
+};
+
+/**
+ * Combine multiple OR clauses into a single query (for Solr)
+ * @param {Array<string>} orClauses - Array of OR clauses
+ * @returns {string} Combined query with OR between clauses
+ */
+export const combineOrClauses = (orClauses) => {
+  if (!Array.isArray(orClauses) || orClauses.length === 0) {
+    return '*:*';
+  }
+  if (orClauses.length === 1) {
+    return orClauses[0];
+  }
+  return orClauses.join(' OR ');
+};
+
+/**
+ * Merge Solr response documents from multiple queries
+ * Removes duplicates based on product_id_i
+ * @param {Array<Array>} responseArrays - Array of response.docs arrays
+ * @returns {Array} Merged and deduplicated docs
+ */
+export const mergeSolrResults = (responseArrays) => {
+  const seen = new Set();
+  const merged = [];
+
+  responseArrays.forEach((docs) => {
+    if (Array.isArray(docs)) {
+      docs.forEach((doc) => {
+        const id = doc.product_id_i;
+        if (id && !seen.has(id)) {
+          seen.add(id);
+          merged.push(doc);
+        }
+      });
+    }
+  });
+
+  return merged;
+};