Map multi-value attributes as arrays in Algolia indexing (#2095)

* Map multi-value attributes as arrays in Algolia indexing

Previously, multi-select attribute values were joined as comma-separated strings. Now they are properly mapped as arrays of strings, enabling better faceting and filtering in Algolia.

Also updates AGENTS.md with changeset workflow documentation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* fix single attr

* fix agents

---------

Co-authored-by: Claude <[email protected]>

Author: lkostrowski

.changeset/purple-rocks-build.md

@@ -0,0 +1,5 @@
+---
+"saleor-app-search": patch
+---
+
+Map multi-value attributes as arrays instead of comma-separated strings in Algolia indexing. They should be properly represented in Algolia now

AGENTS.md

@@ -112,6 +112,11 @@ static ValidationError = BaseError.subclass("ValidationError", {
 3. **Type Safety**: All apps use strict TypeScript - ensure no `any` types
 4. **Testing**: Write unit tests alongside features, E2E tests for critical workflows
 5. **Linting**: Code must pass ESLint rules including custom app-specific rules like `n/no-process-env`
+6. **Changeset**: Functional changes, like new features or fixes should have changeset attached. Do not attach it if code changes do not have visible impact to the user, like refactor. To run changeset: 
+    - Execute `pnpm changeset add` from root directory
+    - Select affected app(s) or package(s)
+    - If many changes applied in single commit, create multiple changesets
+    - Ensure changeset has a good value, describing what was the actual change. It should be less technical than the commit. Best if it has before/after described.
 
 ## App-Specific Notes
 

apps/search/src/lib/algolia/algoliaUtils.test.ts

@@ -128,6 +128,106 @@ describe("algoliaUtils", function () {
       expect(mappedEntity.attributes["booleanFalse"]).toBe(false);
     });
 
+    it("Maps single-value non-boolean attribute as string", () => {
+      const mappedEntity = productAndVariantToAlgolia({
+        channel: "test",
+        enabledKeys: ["attributes"],
+        variant: {
+          id: "id",
+          attributes: [
+            {
+              attribute: {
+                name: "size",
+              },
+              values: [
+                {
+                  name: "Large",
+                  inputType: "DROPDOWN",
+                  boolean: null,
+                },
+              ],
+            },
+          ],
+          name: "product name",
+          metadata: [],
+          product: {
+            __typename: undefined,
+            id: "",
+            name: "",
+            description: undefined,
+            slug: "",
+            variants: undefined,
+            category: undefined,
+            thumbnail: undefined,
+            media: undefined,
+            attributes: [],
+            channelListings: undefined,
+            collections: undefined,
+            metadata: [],
+          },
+        },
+      });
+
+      // @ts-expect-error - record is not typed (attributes are dynamic keys)
+      expect(mappedEntity.attributes["size"]).toBe("Large");
+    });
+
+    it("Maps multi-value attributes as array of strings", () => {
+      const mappedEntity = productAndVariantToAlgolia({
+        channel: "test",
+        enabledKeys: ["attributes"],
+        variant: {
+          id: "id",
+          attributes: [
+            {
+              attribute: {
+                name: "colors",
+              },
+              values: [
+                {
+                  name: "Red",
+                  inputType: "MULTISELECT",
+                  boolean: null,
+                },
+                {
+                  name: "Blue",
+                  inputType: "MULTISELECT",
+                  boolean: null,
+                },
+                {
+                  name: "Green",
+                  inputType: "MULTISELECT",
+                  boolean: null,
+                },
+              ],
+            },
+          ],
+          name: "product name",
+          metadata: [],
+          product: {
+            __typename: undefined,
+            id: "",
+            name: "",
+            description: undefined,
+            slug: "",
+            variants: undefined,
+            category: undefined,
+            thumbnail: undefined,
+            media: undefined,
+            attributes: [],
+            channelListings: undefined,
+            collections: undefined,
+            metadata: [],
+          },
+        },
+      });
+
+      // @ts-expect-error - record is not typed (attributes are dynamic keys)
+      expect(mappedEntity.attributes["colors"]).toStrictEqual(["Red", "Blue", "Green"]);
+      // @ts-expect-error - record is not typed (attributes are dynamic keys)
+      expect(Array.isArray(mappedEntity.attributes["colors"])).toBe(true);
+    });
+
     it("Filters out inactive variants from otherVariants", () => {
       const currentChannel = "channel-1";
       const mappedEntity = productAndVariantToAlgolia({

apps/search/src/lib/algolia/algoliaUtils.ts

@@ -92,7 +92,7 @@ const mapSelectedAttributesToRecord = (attr: ProductAttributesDataFragment) => {
    */
   const filteredValues = attr.values.filter((v) => !!v.name?.length);
 
-  let value: string | boolean;
+  let value: string | boolean | string[];
 
   /**
    * Strategy for boolean type only
@@ -101,18 +101,20 @@ const mapSelectedAttributesToRecord = (attr: ProductAttributesDataFragment) => {
    */
   if (isAttributeValueBooleanType(filteredValues)) {
     value = filteredValues[0].boolean;
+  } else if (filteredValues.length === 1 && filteredValues[0].name) {
+    value = filteredValues[0].name;
   } else {
     /**
      * Fallback to initial/previous behavior
      * TODO: Its not correct to use "name" field always. E.g. for plaintext field more accurate is "plainText",
      *   for "date" field there are date and dateTime fields. "Name" can work on the frontend but doesn't fit for faceting
      */
-    value = filteredValues.map((v) => v.name).join(", ") || "";
+    value = filteredValues.map((v) => v.name).filter(isNotNil);
   }
 
   return {
     [attr.attribute.name]: value,
-  } as Record<string, string | boolean>;
+  } as Record<string, string | boolean | string[]>;
 };
 
 export function productAndVariantToAlgolia({