@akinon/next 1.48.0-rc.7 → 1.49.0

package/data/server/category.ts

@@ -5,32 +5,26 @@ import { category, product } from '../urls';
 import { Cache, CacheKey } from '../../lib/cache';
 import { parse } from 'lossless-json';
 import logger from '../../utils/log';
-import { headers as nHeaders } from 'next/headers';
-import { ServerVariables } from '../../utils/server-variables';
 
 function getCategoryDataHandler(
   pk: number,
-  locale: string,
-  currency: string,
   searchParams?: URLSearchParams,
   headers?: Record<string, string>
 ) {
   return async function () {
     const params = generateCommerceSearchParams(searchParams);
 
-    const rawData = await appFetch<string>({
-      url: `${category.getCategoryByPk(pk)}${params ? params : ''}`,
-      locale,
-      currency,
-      init: {
+    const rawData = await appFetch<string>(
+      `${category.getCategoryByPk(pk)}${params ? params : ''}`,
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json',
           ...(headers ?? {})
         }
       },
-      responseType: FetchResponseType.TEXT
-    });
+      FetchResponseType.TEXT
+    );
 
     let data: GetCategoryResponse;
 
@@ -64,17 +58,15 @@ function getCategoryDataHandler(
       return { data, breadcrumbData: undefined };
     }
 
-    const breadcrumbData = await appFetch<any>({
-      url: product.breadcrumbUrl(menuItemModel),
-      locale,
-      currency,
-      init: {
+    const breadcrumbData = await appFetch<any>(
+      product.breadcrumbUrl(menuItemModel),
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json'
         }
       }
-    });
+    );
 
     return { data, breadcrumbData: breadcrumbData?.menu };
   };
@@ -83,44 +75,33 @@ function getCategoryDataHandler(
 export const getCategoryData = ({
   pk,
   searchParams,
-  headers,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency
+  headers
 }: {
   pk: number;
-  locale?: string;
-  currency?: string;
   searchParams?: URLSearchParams;
   headers?: Record<string, string>;
 }) => {
   return Cache.wrap(
     CacheKey.Category(pk, searchParams, headers),
-    locale,
-    getCategoryDataHandler(pk, locale, currency, searchParams, headers),
+    getCategoryDataHandler(pk, searchParams, headers),
     {
       expire: 300
     }
   );
 };
 
-function getCategoryBySlugDataHandler(
-  slug: string,
-  locale: string,
-  currency: string
-) {
+function getCategoryBySlugDataHandler(slug: string) {
   return async function () {
-    const rawData = await appFetch<string>({
-      url: category.getCategoryBySlug(slug),
-      locale,
-      currency,
-      init: {
+    const rawData = await appFetch<string>(
+      category.getCategoryBySlug(slug),
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json'
         }
       },
-      responseType: FetchResponseType.TEXT
-    });
+      FetchResponseType.TEXT
+    );
 
     let data: GetCategoryResponse;
 
@@ -148,15 +129,10 @@ function getCategoryBySlugDataHandler(
   };
 }
 
-export const getCategoryBySlugData = async ({
-  slug,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency
-}) => {
+export const getCategoryBySlugData = async ({ slug }) => {
   return Cache.wrap(
     CacheKey.CategorySlug(slug),
-    locale,
-    getCategoryBySlugDataHandler(slug, locale, currency),
+    getCategoryBySlugDataHandler(slug),
     {
       expire: 300
     }

package/data/server/flatpage.ts

@@ -2,23 +2,13 @@ import { flatpage } from '../urls';
 import { FlatPage } from '../../types';
 import appFetch from '../../utils/app-fetch';
 import { Cache, CacheKey } from '../../lib/cache';
-import { ServerVariables } from '../../utils/server-variables';
 
-const getFlatPageDataHandler = (
-  pk: number,
-  locale: string,
-  currency: string
-) => {
+const getFlatPageDataHandler = (pk: number) => {
   return async function () {
-    const data = await appFetch<FlatPage>({
-      url: flatpage.getFlatPageByPk(pk),
-      locale,
-      currency,
-      init: {
-        headers: {
-          Accept: 'application/json',
-          'Content-Type': 'application/json'
-        }
+    const data = await appFetch<FlatPage>(flatpage.getFlatPageByPk(pk), {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
       }
     });
 
@@ -26,18 +16,6 @@ const getFlatPageDataHandler = (
   };
 };
 
-export const getFlatPageData = ({
-  pk,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency
-}: {
-  pk: number;
-  locale?: string;
-  currency?: string;
-}) => {
-  return Cache.wrap(
-    CacheKey.FlatPage(pk),
-    locale,
-    getFlatPageDataHandler(pk, locale, currency)
-  );
+export const getFlatPageData = ({ pk }: { pk: number }) => {
+  return Cache.wrap(CacheKey.FlatPage(pk), getFlatPageDataHandler(pk));
 };

package/data/server/form.ts

@@ -1,21 +1,15 @@
-import { Cache, CacheKey } from '../../lib/cache';
-import { FormType } from '../../types/commerce/form';
+import { Cache, CacheKey } from "../../lib/cache";
+import { FormType } from "../../types/commerce/form";
 
-import appFetch from '../../utils/app-fetch';
-import { ServerVariables } from '../../utils/server-variables';
-import { form } from '../urls';
+import appFetch from "../../utils/app-fetch";
+import { form } from "../urls";
 
-const getFormDataHandler = (pk: number, locale: string, currency: string) => {
+const getFormDataHandler = (pk: number) => {
   return async function () {
-    const data = await appFetch<FormType>({
-      url: form.getForm(pk),
-      locale,
-      currency,
-      init: {
-        headers: {
-          Accept: 'application/json',
-          'Content-Type': 'application/json'
-        }
+    const data = await appFetch<FormType>(form.getForm(pk), {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
       }
     });
 
@@ -23,18 +17,6 @@ const getFormDataHandler = (pk: number, locale: string, currency: string) => {
   };
 };
 
-export const getFormData = ({
-  pk,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency
-}: {
-  pk: number;
-  locale?: string;
-  currency?: string;
-}) => {
-  return Cache.wrap(
-    CacheKey.Form(pk),
-    locale,
-    getFormDataHandler(pk, locale, currency)
-  );
+export const getFormData = ({ pk }: { pk: number }) => {
+  return Cache.wrap(CacheKey.Form(pk), getFormDataHandler(pk));
 };

package/data/server/landingpage.ts

@@ -2,42 +2,23 @@ import { landingpage } from '../urls';
 import { LandingPage } from '../../types/commerce/landingpage';
 import appFetch from '../../utils/app-fetch';
 import { Cache, CacheKey } from '../../lib/cache';
-import { ServerVariables } from '../../utils/server-variables';
 
-const getLandingPageHandler = (
-  pk: number,
-  locale: string,
-  currency: string
-) => {
+const getLandingPageHandler = (pk: number) => {
   return async function () {
-    const data = await appFetch<LandingPage>({
-      url: landingpage.getLandingPageByPk(pk),
-      locale,
-      currency,
-      init: {
+    const data = await appFetch<LandingPage>(
+      landingpage.getLandingPageByPk(pk),
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json'
         }
       }
-    });
+    );
 
     return data;
   };
 };
 
-export const getLandingPageData = ({
-  pk,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency
-}: {
-  pk: number;
-  locale?: string;
-  currency?: string;
-}) => {
-  return Cache.wrap(
-    CacheKey.LandingPage(pk),
-    locale,
-    getLandingPageHandler(pk, locale, currency)
-  );
+export const getLandingPageData = ({ pk }: { pk: number }) => {
+  return Cache.wrap(CacheKey.LandingPage(pk), getLandingPageHandler(pk));
 };

package/data/server/list.ts

@@ -5,30 +5,25 @@ import { generateCommerceSearchParams } from '../../utils';
 import appFetch, { FetchResponseType } from '../../utils/app-fetch';
 import { parse } from 'lossless-json';
 import logger from '../../utils/log';
-import { ServerVariables } from '../../utils/server-variables';
 
 const getListDataHandler = (
-  locale,
-  currency,
   searchParams: URLSearchParams,
   headers?: Record<string, string>
 ) => {
   return async function () {
     const params = generateCommerceSearchParams(searchParams);
 
-    const rawData = await appFetch<string>({
-      url: `${category.list}${params}`,
-      locale,
-      currency,
-      init: {
+    const rawData = await appFetch<string>(
+      `${category.list}${params}`,
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json',
           ...(headers ?? {})
         }
       },
-      responseType: FetchResponseType.TEXT
-    });
+      FetchResponseType.TEXT
+    );
 
     let data: GetCategoryResponse;
 
@@ -56,20 +51,15 @@ const getListDataHandler = (
 };
 
 export const getListData = async ({
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency,
   searchParams,
   headers
 }: {
-  locale?: string;
-  currency?: string;
   searchParams: URLSearchParams;
   headers?: Record<string, string>;
 }) => {
   return Cache.wrap(
     CacheKey.List(searchParams, headers),
-    locale,
-    getListDataHandler(locale, currency, searchParams, headers),
+    getListDataHandler(searchParams, headers),
     {
       expire: 300
     }

package/data/server/menu.ts

@@ -1,7 +1,6 @@
 import { Cache, CacheKey } from '../../lib/cache';
 import { MenuItemType } from '../../types';
 import appFetch from '../../utils/app-fetch';
-import { ServerVariables } from '../../utils/server-variables';
 import { misc } from '../urls';
 
 interface MenuResponse {
@@ -9,8 +8,6 @@ interface MenuResponse {
 }
 
 interface MenuHandlerParams {
-  locale?: string;
-  currency?: string;
   depth?: number;
   parent?: string;
 }
@@ -18,18 +15,9 @@ interface MenuHandlerParams {
 const DEFAULT_DEPTH = 3;
 
 const getMenuHandler =
-  ({
-    locale = ServerVariables.locale,
-    currency = ServerVariables.currency,
-    depth,
-    parent
-  }: MenuHandlerParams = {}) =>
+  ({ depth, parent }: MenuHandlerParams = { depth: DEFAULT_DEPTH }) =>
   async () => {
-    const response = await appFetch<MenuResponse>({
-      url: misc.menus(depth ?? DEFAULT_DEPTH, parent),
-      locale,
-      currency
-    });
+    const response = await appFetch<MenuResponse>(misc.menus(depth, parent));
 
     return response?.menu;
   };
@@ -42,7 +30,6 @@ const getMenuHandler =
 export const getMenu = async (params?: MenuHandlerParams) => {
   return Cache.wrap(
     CacheKey.Menu(params?.depth ?? DEFAULT_DEPTH, params?.parent),
-    params?.locale ?? ServerVariables.locale,
     getMenuHandler(params)
   );
 };

package/data/server/product.ts

@@ -1,22 +1,20 @@
 import { Cache, CacheKey } from '../../lib/cache';
 import { product } from '../urls';
-import { ProductCategoryResult, ProductResult } from '../../types';
+import {
+  BreadcrumbResultType,
+  ProductCategoryResult,
+  ProductResult
+} from '../../types';
 import appFetch from '../../utils/app-fetch';
-import { ServerVariables } from '../../utils/server-variables';
-import logger from '../../utils/log';
 
 type GetProduct = {
   pk: number;
-  locale?: string;
-  currency?: string;
   searchParams?: URLSearchParams;
   groupProduct?: boolean;
 };
 
 const getProductDataHandler = ({
   pk,
-  locale,
-  currency,
   searchParams,
   groupProduct
 }: GetProduct) => {
@@ -33,53 +31,33 @@ const getProductDataHandler = ({
           .join('&');
     }
 
-    const data = await appFetch<ProductResult>({
-      url,
-      locale,
-      currency,
-      init: {
-        headers: {
-          Accept: 'application/json',
-          'Content-Type': 'application/json'
-        }
+    const data = await appFetch<ProductResult>(url, {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
       }
     });
 
     const categoryUrl = product.categoryUrl(data.product.pk);
 
-    const productCategoryData = await appFetch<ProductCategoryResult>({
-      url: categoryUrl,
-      locale,
-      currency,
-      init: {
+    const productCategoryData = await appFetch<ProductCategoryResult>(
+      categoryUrl,
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json'
         }
       }
-    });
-
-    const menuItemModel = productCategoryData?.results[0]?.menuitemmodel;
+    );
 
-    if (!menuItemModel) {
-      logger.warn('menuItemModel is undefined, skipping breadcrumbData fetch', {
-        handler: 'getProductDataHandler',
-        pk
-      });
-      return { data, breadcrumbData: undefined };
-    }
-
-    const breadcrumbUrl = product.breadcrumbUrl(menuItemModel);
+    const breadcrumbUrl = product.breadcrumbUrl(
+      productCategoryData.results[0].menuitemmodel
+    );
 
-    const breadcrumbData = await appFetch<any>({
-      url: breadcrumbUrl,
-      locale,
-      currency,
-      init: {
-        headers: {
-          Accept: 'application/json',
-          'Content-Type': 'application/json'
-        }
+    const breadcrumbData = await appFetch<any>(breadcrumbUrl, {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
       }
     });
 
@@ -92,8 +70,6 @@ const getProductDataHandler = ({
 
 export const getProductData = async ({
   pk,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency,
   searchParams,
   groupProduct
 }: GetProduct) => {
@@ -102,8 +78,7 @@ export const getProductData = async ({
       pk,
       searchParams ?? new URLSearchParams()
     ),
-    locale,
-    getProductDataHandler({ pk, locale, currency, searchParams, groupProduct }),
+    getProductDataHandler({ pk, searchParams, groupProduct }),
     {
       expire: 300
     }

package/data/server/seo.ts

@@ -1,15 +1,23 @@
 import appFetch from '../../utils/app-fetch';
 import { Cache, CacheKey } from '../../lib/cache';
 import { misc } from '../../data/urls';
-import { ServerVariables } from '../../utils/server-variables';
+import logger from '../../utils/log';
 
-interface SeoDataParams {
-  url: string;
-  locale?: string;
-  currency?: string;
+function getRootSeoDataHandler() {
+  return async function () {
+    let data = {};
+
+    try {
+      data = await appFetch<{ [key: string]: string }>(misc.cmsSeo('/'));
+    } catch (error) {
+      logger.error('Error while fetching root seo data', error);
+    }
+
+    return data;
+  };
 }
 
-function getSeoDataHandler({ url, locale, currency }: SeoDataParams) {
+function getSeoDataHandler(url: string) {
   return async function () {
     let data = {} as {
       title: string;
@@ -19,7 +27,7 @@ function getSeoDataHandler({ url, locale, currency }: SeoDataParams) {
     };
 
     try {
-      data = await appFetch({ url: misc.cmsSeo(url), locale, currency });
+      data = await appFetch(misc.cmsSeo(url));
     } catch (error) {
       // logger.error('Error while fetching seo data', { url, error });
     }
@@ -28,14 +36,13 @@ function getSeoDataHandler({ url, locale, currency }: SeoDataParams) {
   };
 }
 
-export const getSeoData = async (
-  url,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency
-) => {
-  return Cache.wrap(
-    CacheKey.Seo(url),
-    locale,
-    getSeoDataHandler({ url, locale, currency })
-  );
+/**
+ * @deprecated Use getSeoData instead
+ */
+export const getRootSeo = async () => {
+  return Cache.wrap(CacheKey.RootSeo, getRootSeoDataHandler());
+};
+
+export const getSeoData = async (url: string) => {
+  return Cache.wrap(CacheKey.Seo(url), getSeoDataHandler(url));
 };

package/data/server/special-page.ts

@@ -4,30 +4,25 @@ import { GetCategoryResponse } from '../../types';
 import { generateCommerceSearchParams } from '../../utils';
 import appFetch from '../../utils/app-fetch';
 import header from '../../redux/reducers/header';
-import { ServerVariables } from '../../utils/server-variables';
 
 const getSpecialPageDataHandler = (
   pk: number,
-  locale: string,
-  currency: string,
   searchParams: URLSearchParams,
   headers?: Record<string, string>
 ) => {
   return async function () {
     const params = generateCommerceSearchParams(searchParams);
 
-    const data: GetCategoryResponse = await appFetch({
-      url: `${category.getSpecialPageByPk(pk)}${params}`,
-      locale,
-      currency,
-      init: {
+    const data: GetCategoryResponse = await appFetch(
+      `${category.getSpecialPageByPk(pk)}${params}`,
+      {
         headers: {
           Accept: 'application/json',
           'Content-Type': 'application/json',
           ...(headers ?? {})
         }
       }
-    });
+    );
 
     return data;
   };
@@ -35,21 +30,16 @@ const getSpecialPageDataHandler = (
 
 export const getSpecialPageData = async ({
   pk,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency,
   searchParams,
   headers
 }: {
   pk: number;
-  locale?: string;
-  currency?: string;
   searchParams: URLSearchParams;
   headers?: Record<string, string>;
 }) => {
   return Cache.wrap(
     CacheKey.SpecialPage(pk, searchParams, headers),
-    locale,
-    getSpecialPageDataHandler(pk, locale, currency, searchParams, headers),
+    getSpecialPageDataHandler(pk, searchParams, headers),
     {
       expire: 300
     }

package/data/server/widget.ts

@@ -3,32 +3,25 @@ import 'server-only';
 import { CacheOptions, WidgetResultType } from '../../types';
 import appFetch from '../../utils/app-fetch';
 import { widgets } from '../urls';
-import { ServerVariables } from '../../utils/server-variables';
 
-const getWidgetDataHandler =
-  (slug: string, locale: string, currency: string) => async () => {
-    if (!slug) {
-      return null;
-    }
+const getWidgetDataHandler = (slug: string) => async () => {
+  if (!slug) {
+    return null;
+  }
 
-    return await appFetch({ url: widgets.getWidget(slug), locale, currency });
-  };
+  return await appFetch(widgets.getWidget(slug));
+};
 
 export const getWidgetData = async <T>({
   slug,
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency,
   cacheOptions
 }: {
   slug: string;
-  locale?: string;
-  currency?: string;
   cacheOptions?: CacheOptions;
 }): Promise<WidgetResultType<T>> => {
   return Cache.wrap(
     CacheKey.Widget(slug),
-    locale,
-    getWidgetDataHandler(slug, locale, currency),
+    getWidgetDataHandler(slug),
     cacheOptions
   );
 };