apolloClient.ts

import { ApolloClient, InMemoryCache } from "@apollo/client";
import { ProductType, Format, Genre, ElectronicsCategory } from "./typeDefs";

type ArgsType = {
  searchTerm: string;
  productType: ProductType;
  format: Format;
  genres: Genre[];
  category: ElectronicsCategory;
  sortField: string;
  sortOrder: string;
};

interface ProductRef {
  __ref: string;
}

export const apolloClient = new ApolloClient({
  uri: "http://it2810-14.idi.ntnu.no:3001/graphql",
  cache: new InMemoryCache({
    typePolicies: {
      Query: {
        fields: {
          products: {
            // Cache based on arguments ('where' filter)
            keyArgs: ["where"],
            merge(_, incoming) {
              return incoming;
            },
          },
          searchProducts: {
            keyArgs: ["searchTerm", "productType", "format", "genres", "category", "sortField", "sortOrder"],
            merge(existing = [], incoming, { args }) {
              // If any key argument has changed, replace existing data with incoming
              if (args) {
                const existingKeyArgs: ArgsType = {
                  searchTerm: args.searchTerm,
                  productType: args.productType,
                  format: args.format,
                  genres: args.genres,
                  category: args.category,
                  sortField: args.sortField,
                  sortOrder: args.sortOrder,
                };

                // Check if existing data matches incoming arguments
                const isFreshDataNeeded = Object.keys(existingKeyArgs).some((key) => {
                  return existingKeyArgs[key as keyof ArgsType] !== args[key as keyof ArgsType];
                });

                // If arguments change, return incoming as fresh data
                if (isFreshDataNeeded) {
                  return incoming;
                }
              }

              // Create a map to ensure uniqueness
              const productMap = new Map<string, ProductRef>(existing.map((item: ProductRef) => [item.__ref, item]));
              incoming.forEach((item: ProductRef) => productMap.set(item.__ref, item));

              return Array.from(productMap.values());
            },
          },
          chats: {
            merge(_, incoming) {
              return incoming;
            },
          },
          users: {
            merge(_, incoming) {
              return incoming;
            },
          },
        },
      },
      CProduct: {
        keyFields: ["id"], // Identify products uniquely by id
        fields: {
          favoritedBy: {
            merge(_, incoming) {
              return incoming;
            },
          },
        },
      },
      User: {
        fields: {
          favoritedProducts: {
            merge(_, incoming) {
              // Replace the list with the incoming data.
              return incoming;
            },
          },
          productsForSale: {
            merge(_, incoming) {
              // Replace the list with the incoming data.
              return incoming;
            },
          },
        },
      },
    },
  }),
});