@unchainedshop/api 3.0.0-rc9 → 3.0.0

package/src/loaders/index.ts

@@ -12,75 +12,22 @@ import {
   AssortmentMediaText,
 } from '@unchainedshop/core-assortments';
 import { File } from '@unchainedshop/core-files';
-export interface UnchainedLoaders {
-  loaders: {
-    productLoader: InstanceType<typeof DataLoader<{ productId: string }, Product>>;
-    productLoaderBySKU: InstanceType<typeof DataLoader<{ sku: string }, Product>>;
-    productTextLoader: InstanceType<
-      typeof DataLoader<{ productId: string; locale: string }, ProductText>
-    >;
-    productMediaTextLoader: InstanceType<
-      typeof DataLoader<{ productMediaId: string; locale: string }, ProductMediaText>
-    >;
-
-    fileLoader: InstanceType<typeof DataLoader<{ fileId: string }, File>>;
-
-    filterLoader: InstanceType<typeof DataLoader<{ filterId: string }, Filter>>;
-    filterTextLoader: InstanceType<
-      typeof DataLoader<{ filterId: string; filterOptionValue?: string; locale: string }, FilterText>
-    >;
-
-    assortmentLoader: InstanceType<typeof DataLoader<{ assortmentId: string }, Assortment>>;
-    assortmentTextLoader: InstanceType<
-      typeof DataLoader<{ assortmentId: string; locale: string }, AssortmentText>
-    >;
-    assortmentLinkLoader: InstanceType<
-      typeof DataLoader<{ parentAssortmentId: string; childAssortmentId: string }, AssortmentLink>
-    >;
-    assortmentLinksLoader: InstanceType<
-      typeof DataLoader<{ parentAssortmentId?: string; assortmentId?: string }, AssortmentLink[]>
-    >;
-    assortmentProductLoader: InstanceType<
-      typeof DataLoader<{ assortmentId: string; productId: string }, AssortmentProduct>
-    >;
-    assortmentMediaTextLoader: InstanceType<
-      typeof DataLoader<{ assortmentMediaId: string; locale: string }, AssortmentMediaText>
-    >;
-
-    productMediasLoader: InstanceType<typeof DataLoader<{ productId?: string }, ProductMedia[]>>;
-    assortmentMediasLoader: InstanceType<
-      typeof DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>
-    >;
-  };
-}
-
-function getLocaleStrings(localeObj: Intl.Locale) {
-  return [localeObj.baseName, localeObj.language, systemLocale.baseName, systemLocale.language];
-}
 
-function findMatchingText(texts, localeStrings) {
-  return localeStrings.reduce((acc, localeString) => {
-    if (acc) return acc;
-    return texts.find((p) => p.locale.toLowerCase() === localeString.toLowerCase());
-  }, null);
+function getLocaleStrings(locale: string) {
+  const localeObj = new Intl.Locale(locale);
+  return [
+    ...new Set([
+      localeObj.baseName.toLowerCase(),
+      localeObj.language.toLowerCase(),
+      systemLocale.baseName.toLowerCase(),
+      systemLocale.language.toLowerCase(),
+    ]),
+  ];
 }
 
-function getFilteredQueries({ queries, texts, filterFn }) {
-  return queries.map(({ locale, ...queryParams }) => {
-    const localeObj = new Intl.Locale(locale);
-
-    const filteredTexts = texts.filter(filterFn(queryParams));
-    if (!filteredTexts.length) return null;
-
-    const localeStrings = getLocaleStrings(localeObj);
-    const filterText = findMatchingText(filteredTexts, localeStrings);
-    return filterText || filteredTexts[0];
-  });
-}
-
-const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['loaders']> => {
+const loaders = async (unchainedAPI: UnchainedCore) => {
   return {
-    assortmentLoader: new DataLoader(async (queries) => {
+    assortmentLoader: new DataLoader<{ assortmentId: string }, Assortment>(async (queries) => {
       const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
 
       const assortments = await unchainedAPI.modules.assortments.findAssortments({
@@ -89,35 +36,45 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         includeLeaves: true,
       });
 
-      return queries.map(({ assortmentId }) => {
-        return assortments.find((assortment) => {
-          if (assortment._id !== assortmentId) return false;
-          return true;
-        });
-      });
+      const assortmentMap = {};
+      for (const assortment of assortments) {
+        assortmentMap[assortment._id] = assortment;
+      }
+      return queries.map((q) => assortmentMap[q.assortmentId]);
     }),
 
-    assortmentTextLoader: new DataLoader(async (queries) => {
-      const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+    assortmentTextLoader: new DataLoader<{ assortmentId: string; locale: string }, AssortmentText>(
+      async (queries) => {
+        const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
 
-      const texts = await unchainedAPI.modules.assortments.texts.findTexts(
-        { assortmentId: { $in: assortmentIds } },
-        {
-          sort: {
-            assortmentId: 1,
+        const texts = await unchainedAPI.modules.assortments.texts.findTexts(
+          { assortmentId: { $in: assortmentIds } },
+          {
+            sort: {
+              assortmentId: 1,
+            },
           },
-        },
-      );
-
-      const filterFn =
-        ({ assortmentId }) =>
-        (text) =>
-          text.assortmentId === assortmentId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
-    }),
-
-    assortmentMediaTextLoader: new DataLoader(async (queries) => {
+        );
+
+        const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+        const textsMap = {};
+        const localeMap = Object.fromEntries(
+          queryLocales.flatMap((queryLocale) => {
+            return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+          }),
+        );
+        for (const text of texts) {
+          const locale = localeMap[text.locale.toLowerCase()];
+          textsMap[locale + text.assortmentId] = text;
+        }
+        return queries.map((q) => textsMap[q.locale.toLowerCase() + q.assortmentId]);
+      },
+    ),
+
+    assortmentMediaTextLoader: new DataLoader<
+      { assortmentMediaId: string; locale: string },
+      AssortmentMediaText
+    >(async (queries) => {
       const assortmentMediaIds = [...new Set(queries.map((q) => q.assortmentMediaId).filter(Boolean))];
 
       const texts = await unchainedAPI.modules.assortments.media.texts.findMediaTexts(
@@ -129,93 +86,150 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       );
 
-      const filterFn =
-        ({ assortmentMediaId }) =>
-        (text) =>
-          text.assortmentMediaId === assortmentMediaId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[locale + text.assortmentMediaId] = text;
+      }
+      return queries.map((q) => textsMap[q.locale.toLowerCase() + q.assortmentMediaId]);
     }),
 
-    assortmentMediasLoader: new DataLoader(async (queries) => {
-      const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
-      const assortmentMediaItems = await unchainedAPI.modules.assortments.media.findAssortmentMedias({
-        assortmentId: { $in: assortmentIds },
-      });
-
-      return queries.map((q) => {
-        return assortmentMediaItems.filter((i) => {
-          return i.assortmentId === q.assortmentId;
+    assortmentMediasLoader: new DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>(
+      async (queries) => {
+        const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+        const assortmentMediaItems = await unchainedAPI.modules.assortments.media.findAssortmentMedias({
+          assortmentId: { $in: assortmentIds },
         });
-      });
-    }),
 
-    assortmentLinkLoader: new DataLoader(async (queries) => {
+        const assortmentMediaMap = {};
+        for (const assortmentMedia of assortmentMediaItems) {
+          if (!assortmentMediaMap[assortmentMedia.assortmentId]) {
+            assortmentMediaMap[assortmentMedia.assortmentId] = [assortmentMedia];
+          } else {
+            assortmentMediaMap[assortmentMedia.assortmentId].push(assortmentMedia);
+          }
+        }
+        return queries.map((q) => assortmentMediaMap[q.assortmentId] || []);
+      },
+    ),
+
+    assortmentLinkLoader: new DataLoader<
+      { parentAssortmentId: string; childAssortmentId: string },
+      AssortmentLink
+    >(async (queries) => {
       const parentAssortmentIds = [...new Set(queries.map((q) => q.parentAssortmentId).filter(Boolean))];
 
       const links = await unchainedAPI.modules.assortments.links.findLinks({
         parentAssortmentIds,
       });
 
-      return queries.map(({ parentAssortmentId, childAssortmentId }) => {
-        return links.find((link) => {
-          if (link.parentAssortmentId !== parentAssortmentId) return false;
-          if (childAssortmentId && link.childAssortmentId !== childAssortmentId) return false;
-          return true;
-        });
+      const assortmentLinkMap = {};
+      for (const link of links) {
+        if (!assortmentLinkMap[link.parentAssortmentId]) {
+          assortmentLinkMap[link.parentAssortmentId] = [link];
+        } else {
+          assortmentLinkMap[link.parentAssortmentId].push(link);
+        }
+      }
+
+      return queries.map((q) => {
+        if (q.childAssortmentId) {
+          return assortmentLinkMap[q.parentAssortmentId].find(
+            (link) => link.childAssortmentId === q.childAssortmentId,
+          );
+        }
+        return assortmentLinkMap[q.parentAssortmentId][0];
       });
     }),
 
-    assortmentLinksLoader: new DataLoader(async (queries) => {
-      const parentAssortmentIds = [
-        ...new Set(queries.flatMap((q) => q.parentAssortmentId).filter(Boolean)),
-      ];
-      const assortmentIds = [...new Set(queries.flatMap((q) => q.assortmentId).filter(Boolean))];
-
-      const linksByParentAssortmentId =
-        parentAssortmentIds?.length &&
-        (await unchainedAPI.modules.assortments.links.findLinks({
-          parentAssortmentIds,
-        }));
-      const linksByAssortmentId =
-        assortmentIds?.length &&
-        (await unchainedAPI.modules.assortments.links.findLinks({
-          assortmentIds,
-        }));
-
-      return queries.map(({ parentAssortmentId, assortmentId }) => {
-        if (parentAssortmentId) {
-          return linksByParentAssortmentId.filter(
-            (link) => link.parentAssortmentId === parentAssortmentId,
-          );
+    assortmentLinksLoader: new DataLoader<
+      { parentAssortmentId?: string; childAssortmentId?: string; assortmentId?: string },
+      AssortmentLink[]
+    >(async (queries) => {
+      const parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean);
+      const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean);
+      const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean);
+
+      const allLinks = await unchainedAPI.modules.assortments.links.findLinks({
+        assortmentIds: [...new Set([...parentAssortmentIds, ...childAssortmentIds, ...assortmentIds])],
+      });
+
+      const parentAssortmentLinkMap = {};
+      const childAssortmentLinkMap = {};
+
+      for (const link of allLinks) {
+        if (!parentAssortmentLinkMap[link.parentAssortmentId]) {
+          parentAssortmentLinkMap[link.parentAssortmentId] = [link];
+        } else {
+          parentAssortmentLinkMap[link.parentAssortmentId].push(link);
         }
-        if (assortmentId) {
-          return linksByAssortmentId.filter(
-            (link) =>
-              link.parentAssortmentId === assortmentId || link.childAssortmentId === assortmentId,
-          );
+
+        if (!childAssortmentLinkMap[link.childAssortmentId]) {
+          childAssortmentLinkMap[link.childAssortmentId] = [link];
+        } else {
+          childAssortmentLinkMap[link.childAssortmentId].push(link);
+        }
+      }
+
+      return queries.map((q) => {
+        if (q.parentAssortmentId) {
+          return parentAssortmentLinkMap[q.parentAssortmentId] || [];
+        } else if (q.childAssortmentId) {
+          return childAssortmentLinkMap[q.childAssortmentId] || [];
         }
-        return [];
+        return [
+          ...(parentAssortmentLinkMap[q.assortmentId] || []),
+          ...(childAssortmentLinkMap[q.assortmentId] || []),
+        ];
       });
     }),
 
-    assortmentProductLoader: new DataLoader(async (queries) => {
+    assortmentProductLoader: new DataLoader<
+      { assortmentId: string; productId: string },
+      AssortmentProduct
+    >(async (queries) => {
       const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
 
-      const assortmentProducts = await unchainedAPI.modules.assortments.products.findProducts({
+      const assortmentProducts = await unchainedAPI.modules.assortments.products.findAssortmentProducts({
         assortmentIds,
       });
 
-      return queries.map(({ assortmentId, productId }) => {
-        return assortmentProducts.find((assortmentProduct) => {
-          if (assortmentProduct.assortmentId !== assortmentId) return false;
-          if (assortmentProduct.productId !== productId) return false;
-          return true;
-        });
-      });
+      const assortmentProductMap = {};
+      for (const assortmentProduct of assortmentProducts) {
+        assortmentProductMap[assortmentProduct.assortmentId + assortmentProduct.productId] =
+          assortmentProduct;
+      }
+      return queries.map((q) => assortmentProductMap[q.assortmentId + q.productId]);
     }),
 
-    filterLoader: new DataLoader(async (queries) => {
+    assortmentProductsLoader: new DataLoader<{ productId: string }, AssortmentProduct[]>(
+      async (queries) => {
+        const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+        const assortmentProducts =
+          await unchainedAPI.modules.assortments.products.findAssortmentProducts({
+            productIds,
+          });
+
+        const assortmentProductsMap = {};
+        for (const assortmentProduct of assortmentProducts) {
+          if (!assortmentProductsMap[assortmentProduct.productId]) {
+            assortmentProductsMap[assortmentProduct.productId] = [assortmentProduct];
+          } else {
+            assortmentProductsMap[assortmentProduct.productId].push(assortmentProduct);
+          }
+        }
+        return queries.map((q) => assortmentProductsMap[q.productId] || []);
+      },
+    ),
+
+    filterLoader: new DataLoader<{ filterId: string }, Filter>(async (queries) => {
       const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
 
       const filters = await unchainedAPI.modules.filters.findFilters({
@@ -223,15 +237,18 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         includeInactive: true,
       });
 
-      return queries.map(({ filterId }) => {
-        return filters.find((product) => {
-          if (product._id !== filterId) return false;
-          return true;
-        });
-      });
+      const filterMap = {};
+      for (const filter of filters) {
+        filterMap[filter._id] = filter;
+      }
+
+      return queries.map((q) => filterMap[q.filterId]);
     }),
 
-    filterTextLoader: new DataLoader(async (queries) => {
+    filterTextLoader: new DataLoader<
+      { filterId: string; filterOptionValue?: string; locale: string },
+      FilterText
+    >(async (queries) => {
       const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
 
       const texts = await unchainedAPI.modules.filters.texts.findTexts(
@@ -243,14 +260,21 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       );
 
-      const filterFn =
-        ({ filterId, filterOptionValue }) =>
-        (text) =>
-          text.filterId === filterId && text.filterOptionValue === filterOptionValue;
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[locale + text.filterId + text.filterOptionValue] = text;
+      }
+      return queries.map((q) => textsMap[q.locale.toLowerCase() + q.filterId + q.filterOptionValue]);
     }),
 
-    productLoader: new DataLoader(async (queries) => {
+    productLoader: new DataLoader<{ productId: string }, Product>(async (queries) => {
       const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))]; // you don't need lodash, _.unique my ass
 
       const products = await unchainedAPI.modules.products.findProducts({
@@ -260,15 +284,15 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       });
 
-      return queries.map(({ productId }) => {
-        return products.find((product) => {
-          if (product._id !== productId) return false;
-          return true;
-        });
-      });
+      const productMap = {};
+      for (const product of products) {
+        productMap[product._id] = product;
+      }
+
+      return queries.map((q) => productMap[q.productId]);
     }),
 
-    productLoaderBySKU: new DataLoader(async (queries) => {
+    productLoaderBySKU: new DataLoader<{ sku: string }, Product>(async (queries) => {
       const skus = [...new Set(queries.map((q) => q.sku).filter(Boolean))]; // you don't need lodash, _.unique my ass
 
       const products = await unchainedAPI.modules.products.findProducts({
@@ -278,81 +302,102 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       });
 
-      return queries.map(({ sku }) => {
-        return products.find((product) => {
-          if (product.warehousing?.sku !== sku) return false;
-          return true;
-        });
-      });
-    }),
-
-    productTextLoader: new DataLoader(async (queries) => {
-      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
-
-      const texts = await unchainedAPI.modules.products.texts.findTexts(
-        { productId: { $in: productIds } },
-        {
-          sort: {
-            productId: 1,
-          },
-        },
-      );
-
-      const filterFn =
-        ({ productId }) =>
-        (text) =>
-          text.productId === productId;
+      const productMap = {};
+      for (const product of products) {
+        productMap[product.warehousing!.sku!] = product;
+      }
 
-      return getFilteredQueries({ queries, texts, filterFn });
+      return queries.map((q) => productMap[q.sku]);
     }),
 
-    productMediaTextLoader: new DataLoader(async (queries) => {
-      const productMediaIds = [...new Set(queries.map((q) => q.productMediaId).filter(Boolean))];
-
-      const texts = await unchainedAPI.modules.products.media.texts.findMediaTexts(
-        { productMediaId: { $in: productMediaIds } },
-        {
-          sort: {
-            productMediaId: 1,
+    productTextLoader: new DataLoader<{ productId: string; locale: string }, ProductText>(
+      async (queries) => {
+        const productIds = [...new Set(queries.map((q) => q.productId))].filter(Boolean);
+        const texts = await unchainedAPI.modules.products.texts.findTexts(
+          { productId: { $in: productIds } },
+          {
+            sort: {
+              productId: 1,
+            },
           },
-        },
-      );
-
-      const filterFn =
-        ({ productMediaId }) =>
-        (text) =>
-          text.productMediaId === productMediaId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
-    }),
+        );
+        const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+        const textsMap = {};
+        const localeMap = Object.fromEntries(
+          queryLocales.flatMap((queryLocale) => {
+            return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+          }),
+        );
+        for (const text of texts) {
+          const locale = localeMap[text.locale.toLowerCase()];
+          textsMap[locale + text.productId] = text;
+        }
+        return queries.map((q) => textsMap[q.locale.toLowerCase() + q.productId]);
+      },
+    ),
+
+    productMediaTextLoader: new DataLoader<{ productMediaId: string; locale: string }, ProductMediaText>(
+      async (queries) => {
+        const productMediaIds = [...new Set(queries.map((q) => q.productMediaId).filter(Boolean))];
+
+        const texts = await unchainedAPI.modules.products.media.texts.findMediaTexts(
+          { productMediaId: { $in: productMediaIds } },
+          {
+            sort: {
+              productMediaId: 1,
+            },
+          },
+        );
+
+        const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+        const textsMap = {};
+        const localeMap = Object.fromEntries(
+          queryLocales.flatMap((queryLocale) => {
+            return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+          }),
+        );
+        for (const text of texts) {
+          const locale = localeMap[text.locale.toLowerCase()];
+          textsMap[locale + text.productMediaId] = text;
+        }
+        return queries.map((q) => textsMap[q.locale.toLowerCase() + q.productMediaId]);
+      },
+    ),
 
-    productMediasLoader: new DataLoader(async (queries) => {
+    productMediasLoader: new DataLoader<{ productId?: string }, ProductMedia[]>(async (queries) => {
       const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
       const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
         productId: { $in: productIds },
       });
-      return queries.map((q) => {
-        return productMediaItems.filter((i) => {
-          return i.productId === q.productId;
-        });
-      });
+
+      const productMediaMap = {};
+      for (const productMedia of productMediaItems) {
+        if (!productMediaMap[productMedia.productId]) {
+          productMediaMap[productMedia.productId] = [productMedia];
+        } else {
+          productMediaMap[productMedia.productId].push(productMedia);
+        }
+      }
+      return queries.map((q) => productMediaMap[q.productId] || []);
     }),
 
-    fileLoader: new DataLoader(async (queries) => {
+    fileLoader: new DataLoader<{ fileId: string }, File>(async (queries) => {
       const fileIds = [...new Set(queries.map((q) => q.fileId).filter(Boolean))]; // you don't need lodash, _.unique my ass
 
       const files = await unchainedAPI.modules.files.findFiles({
         _id: { $in: fileIds },
       });
 
-      return queries.map(({ fileId }) => {
-        return files.find((file) => {
-          if (file._id !== fileId) return false;
-          return true;
-        });
-      });
+      const fileMap = {};
+      for (const file of files) {
+        fileMap[file._id] = file;
+      }
+
+      return queries.map((q) => fileMap[q.fileId]);
     }),
   };
 };
 
+export type UnchainedLoaders = Awaited<ReturnType<typeof loaders>>;
+
 export default loaders;

package/src/locale-context.ts

@@ -15,9 +15,6 @@ export interface UnchainedLocaleContext {
   countryContext: string;
   localeContext: Intl.Locale;
   currencyContext: string;
-  remoteAddress?: string;
-  remotePort?: string;
-  userAgent?: string;
 }
 const { NODE_ENV } = process.env;
 
@@ -76,20 +73,14 @@ export const resolveDefaultContext = pMemoize(
 
 export const getLocaleContext = async (
   {
-    remoteAddress,
-    remotePort,
     getHeader,
   }: {
-    remoteAddress: string;
-    remotePort: number | string;
     getHeader: UnchainedHTTPServerContext['getHeader'];
   },
   unchainedAPI: UnchainedCore,
 ): Promise<UnchainedLocaleContext> => {
-  const userAgent = getHeader('user-agent');
-  const context = await resolveDefaultContext(
+  return resolveDefaultContext(
     { acceptLang: getHeader('accept-language'), acceptCountry: getHeader('x-shop-country') },
     unchainedAPI,
   );
-  return { remoteAddress, remotePort: String(remotePort), userAgent, ...context };
 };

package/src/resolvers/mutations/accounts/createUser.ts

@@ -37,7 +37,7 @@ export default async function createUser(root: never, params: UserData, context:
     user = await context.modules.users.updateHeartbeat(user._id, {
       remoteAddress: context.remoteAddress,
       remotePort: context.remotePort,
-      userAgent: context.userAgent,
+      userAgent: context.getHeader('user-agent'),
       locale: context.localeContext.baseName,
       countryCode: context.countryContext,
     });