@mohasinac/appkit 4.43.0 → 4.44.0

package/dist/features/categories/schemas/firestore.js

@@ -20,6 +20,7 @@ export const CATEGORIES_INDEXED_FIELDS = [
     "isActive",
     "isSearchable",
     "showOnHomepage",
+    "searchTxt",
     "createdBy",
     "createdByType",
     "createdByStoreId",
@@ -76,6 +77,31 @@ export const CATEGORIES_PUBLIC_FIELDS = [
     "display",
     "isActive",
     "ancestors",
+    /*
+     * B3. `highlights` and `faqs` were MISSING from both this list and the
+     * updatable one, which is the more interesting half: `CategoryUpdateInput`
+     * derives from UPDATABLE_FIELDS, so a field absent from it is not even
+     * TYPE-LEGAL to update — and both had shipped with no editor at all.
+     * Precedent-by-omission gets closed, not copied.
+     *
+     * `productDefaults` is public because its advisory half (priceGuidance,
+     * specifications, inTheBox) is rendered to buyers and sellers. Its
+     * `taxCodeId` is a reference to an admin-only row, not a secret.
+     */
+    "highlights",
+    "faqs",
+    "contentBody",
+    "descriptionTemplates",
+    "productDefaults",
+    /*
+     * B5. `aliases` is public because it is already published in a form nobody
+     * can withhold: every alias is tokenised into `searchTxt`, which is what the
+     * search endpoint matches on, so the facts are inferable from search results
+     * whether or not the array is in the payload. Withholding it would hide a
+     * useful "also known as" line from the page while changing nothing about
+     * what is reachable.
+     */
+    "aliases",
 ];
 export const CATEGORIES_UPDATABLE_FIELDS = [
     "name",
@@ -89,6 +115,14 @@ export const CATEGORIES_UPDATABLE_FIELDS = [
     "display",
     "isActive",
     "isSearchable",
+    // B3 — see the note in CATEGORIES_PUBLIC_FIELDS. Without these five,
+    // CategoryUpdateInput cannot express them and no editor can save them.
+    "highlights",
+    "faqs",
+    "contentBody",
+    "descriptionTemplates",
+    "productDefaults",
+    "aliases",
 ];
 export const categoryQueryHelpers = {
     bySlug: (slug) => ["slug", "==", slug],
@@ -179,6 +213,12 @@ export const CATEGORY_FIELDS = {
     VIEW_COUNT: "viewCount",
     IS_ACTIVE: "isActive",
     IS_SEARCHABLE: "isSearchable",
+    SEARCH_TXT: "searchTxt",
+    CONTENT_BODY: "contentBody",
+    DESCRIPTION_TEMPLATES: "descriptionTemplates",
+    PRODUCT_DEFAULTS: "productDefaults",
+    /* Dot-path, so a referrer query is one equality and needs no index. */
+    PRODUCT_DEFAULTS_TAX_CODE_ID: "productDefaults.taxCodeId",
     CATEGORY_TYPE: "categoryType",
     CREATED_BY: "createdBy",
     CREATED_AT: "createdAt",
@@ -187,12 +227,43 @@ export const CATEGORY_FIELDS = {
 };
 /**
  * Build a category tree from a flat list of CategoryDocument objects.
+ *
+ * 🛑 ONE INDEXING PASS, then recursion — not a `.filter()` per node.
+ * This used to scan the whole array once per category to find its children,
+ * which is O(n²): 2,209 comparisons at today's 47 nodes, ~109,000 at the ~330
+ * this plan seeds, and **2.25 million** at 1,500. It runs inside
+ * `categoriesRepository.buildTree()`, i.e. on a request path. Grouping by
+ * parent id first makes it O(n log n) (the sorts) and the output is
+ * byte-identical: same roots, same child order, same depths.
+ *
+ * 🛑 The `seen` set is not defensive padding. A root is picked by
+ * `tier === 0`, and nothing stops a corrupt row from being tier 0 *and* a
+ * descendant of its own child (`parentIds` is a denormalised chain that four
+ * different write paths maintain). The old code would recurse forever on that,
+ * and a hung SSR render is worse than a failed one — it holds a function open
+ * for its whole timeout and reports nothing. A revisited node is dropped from
+ * the second position it appears in rather than throwing: a malformed edge
+ * should cost one tile, not the category page.
  */
 export function buildCategoryTree(categories, rootId) {
+    const byParent = new Map();
+    for (const cat of categories) {
+        const parentId = cat.parentIds[cat.parentIds.length - 1];
+        if (!parentId)
+            continue;
+        const bucket = byParent.get(parentId);
+        if (bucket)
+            bucket.push(cat);
+        else
+            byParent.set(parentId, [cat]);
+    }
+    for (const bucket of byParent.values())
+        bucket.sort((a, b) => a.order - b.order);
+    const seen = new Set();
     function buildTree(category, depth) {
-        const children = categories
-            .filter((cat) => cat.parentIds[cat.parentIds.length - 1] === category.id)
-            .sort((a, b) => a.order - b.order)
+        seen.add(category.id);
+        const children = (byParent.get(category.id) ?? [])
+            .filter((child) => !seen.has(child.id))
             .map((child) => buildTree(child, depth + 1));
         return { category, children, depth };
     }