@akinon/next 1.0.0

package/data/client/misc.ts

@@ -0,0 +1,101 @@
+import {
+  EmailSubscriptionType,
+  MenuItemType,
+  WidgetResultType
+} from '../../types';
+import { buildClientRequestUrl } from '../../utils';
+import { misc, widgets } from '../urls';
+import { api } from './api';
+
+type CategoryExtraType = {
+  category_id: number;
+  parent_categories: Array<string>;
+};
+
+type ProductExtraType = {
+  image: string;
+  price: number;
+  product_type: string;
+  retail_price: number;
+};
+
+export interface AutocompleteResponse {
+  groups: Array<{
+    entries: Array<{
+      extra: CategoryExtraType & ProductExtraType;
+      label: string;
+      suggestion_type: string;
+      url: string;
+    }>;
+    suggestion_type: 'Category' | 'Product';
+  }>;
+}
+
+export interface GetLanguageResponse {
+  active_language: string;
+  default_language: string;
+  available_languages: {
+    [key: string]: string;
+  };
+}
+
+export interface SetLanguageResponse {
+  success: boolean;
+}
+
+export const miscApi = api.injectEndpoints({
+  endpoints: (builder) => ({
+    autocomplete: builder.query<AutocompleteResponse, string>({
+      query: (query: string) => ({
+        url: buildClientRequestUrl(`${misc.autocomplete}?search_text=${query}`)
+      })
+    }),
+    emailSubscription: builder.mutation<void, EmailSubscriptionType>({
+      query: (body) => ({
+        url: buildClientRequestUrl(misc.emailSubscription, {
+          contentType: 'application/json'
+        }),
+        method: 'POST',
+        body
+      })
+    }),
+    setLanguage: builder.mutation<any, { language: string }>({
+      query: (body) => ({
+        url: buildClientRequestUrl('/i18n/setlang', {
+          useFormData: true,
+          responseType: 'text'
+        }),
+        method: 'POST',
+        body
+      }),
+      transformResponse: (response, meta) => {
+        return {
+          success: meta.response.status === 200,
+          osessionid: meta.response.headers.get('osessionid')
+        };
+      }
+    }),
+    getWidget: builder.query<WidgetResultType<any>, string>({
+      query: (slug: string) => ({
+        url: buildClientRequestUrl(widgets.getWidgets(slug))
+      })
+    }),
+    getMenu: builder.query<MenuItemType[], number>({
+      query: (depth) => ({
+        url: buildClientRequestUrl(misc.menus(depth))
+      }),
+      transformResponse: (response: { menu: MenuItemType[] }) => {
+        return response.menu;
+      }
+    })
+  }),
+  overrideExisting: true
+});
+
+export const {
+  useAutocompleteQuery,
+  useEmailSubscriptionMutation,
+  useSetLanguageMutation,
+  useGetWidgetQuery,
+  useGetMenuQuery
+} = miscApi;

package/data/client/product.ts

@@ -0,0 +1,90 @@
+import {
+  Basket,
+  FindInStoreFormType,
+  ProductResult,
+  StockResultType
+} from '../../types';
+import { buildClientRequestUrl } from '../../utils';
+import { api } from './api';
+import { product } from '../urls';
+
+export type AddProductResponse = {
+  basket: Basket;
+  osessionid: string;
+};
+
+export type AddProductRequest = {
+  product: number;
+  quantity: number;
+  attributes: any;
+};
+
+type GetProduct = {
+  pk: number;
+  searchParams?: URLSearchParams;
+  groupProduct?: boolean;
+  [key:string]: any;
+};
+
+export const productApi = api.injectEndpoints({
+  endpoints: (build) => ({
+    getProductByPk: build.query<ProductResult, number>({
+      query: (pk) => ({
+        url: buildClientRequestUrl(product.getProductByPk(pk))
+      })
+    }),
+    getProductByParams: build.query<ProductResult, GetProduct>({
+      query: ({pk, searchParams, groupProduct, ...params}) => {
+        let url = groupProduct
+          ? product.getGroupProductByPk(pk)
+          : product.getProductByPk(pk);
+
+        if (params) {
+          url = `${url}?${new URLSearchParams(params).toString()}`;
+        }
+
+        return {
+          url: buildClientRequestUrl(url)
+        };
+      }
+    }),
+    getRetailStoreStock: build.mutation<StockResultType, FindInStoreFormType>({
+      query: (body) => {
+        const { productPk, store, variant } = body;
+        const hasVariant = variant ? `&integration_beden=${variant}` : '';
+        return {
+          url: buildClientRequestUrl(
+            product.getRetailStoreStock(productPk, store, hasVariant),
+            {
+              contentType: 'application/json'
+            }
+          ),
+          method: 'GET'
+        };
+      }
+    }),
+    addProduct: build.mutation<AddProductResponse, AddProductRequest>({
+      query: (body) => ({
+        url: buildClientRequestUrl(product.addProduct, {
+          contentType: 'application/json'
+        }),
+        method: 'POST',
+        body
+      })
+    }),
+    getInstallments: build.query<any, any>({
+      query: (productPk) => ({
+        url: buildClientRequestUrl(product.installments(productPk))
+      })
+    })
+  }),
+  overrideExisting: true
+});
+
+export const {
+  useAddProductMutation,
+  useGetProductByPkQuery,
+  useGetRetailStoreStockMutation,
+  useGetInstallmentsQuery,
+  useGetProductByParamsQuery
+} = productApi;

package/data/client/user.ts

@@ -0,0 +1,83 @@
+import { api } from './api';
+import { user } from '../urls';
+import { ForgotPasswordFormType } from '../../types';
+import { buildClientRequestUrl } from '../../utils';
+
+interface GetCaptchaResponse {
+  siteKey: string;
+  csrfToken: string;
+}
+
+interface ValidateCaptchaRequest {
+  captchaResponse: string;
+  csrfToken: string;
+}
+
+interface ValidateCaptchaResponse {
+  success: boolean;
+}
+
+const userApi = api.injectEndpoints({
+  endpoints: (build) => ({
+    getCaptcha: build.query<GetCaptchaResponse, void>({
+      query: () => buildClientRequestUrl(user.captcha),
+      transformResponse: (response: { html: string }) => {
+        const siteKeyMatch = response.html.match(/sitekey=["|']\w+/gi);
+        const csrfTokenMatch = response.html.match(
+          /name=['|"]csrfmiddlewaretoken['|"] value=['|"]\w+/gi
+        );
+        const siteKey = siteKeyMatch?.[0].replace(/sitekey=["|']/, '') || '';
+        const csrfToken =
+          csrfTokenMatch?.[0].replace(
+            /name=['|"]csrfmiddlewaretoken['|"] value=['|"]/gi,
+            ''
+          ) || '';
+
+        return {
+          siteKey,
+          csrfToken
+        };
+      }
+    }),
+    validateCaptcha: build.mutation<
+      ValidateCaptchaResponse,
+      ValidateCaptchaRequest
+    >({
+      query: (body) => ({
+        url: buildClientRequestUrl(user.captcha, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          'g-recaptcha-response': body.captchaResponse
+        }
+      }),
+      transformResponse: (response: { location: string }) => ({
+        success: response.location === '/'
+      })
+    }),
+    logout: build.mutation<string, void>({
+      query: () => ({
+        url: '/api/logout',
+        method: 'POST'
+      })
+    }),
+    forgotPassword: build.mutation<void, ForgotPasswordFormType>({
+      query: (body) => ({
+        url: buildClientRequestUrl(user.forgotPassword, {
+          contentType: 'application/json'
+        }),
+        method: 'POST',
+        body
+      })
+    })
+  }),
+  overrideExisting: false
+});
+
+export const {
+  useGetCaptchaQuery,
+  useValidateCaptchaMutation,
+  useLogoutMutation,
+  useForgotPasswordMutation
+} = userApi;

package/data/client/wishlist.ts

@@ -0,0 +1,79 @@
+import { FavoriteItem } from '../../types';
+import { buildClientRequestUrl } from '../../utils';
+import { api } from './api';
+import { URLS, wishlist } from '../urls';
+
+export type AddProductRequest = {
+  product: number;
+  quantity: number;
+  attributes: any;
+};
+
+interface GetFavoritesParams {
+  limit?: number;
+  page?: number;
+}
+
+interface GetFavoritesResponse {
+  count: number;
+  results: FavoriteItem[];
+}
+
+interface AddFavoriteResponse {
+  pk: number;
+  product: number;
+}
+
+interface RemoteFavoriteResponse {
+  success: boolean;
+}
+
+export const wishlistApi = api.injectEndpoints({
+  endpoints: (build) => ({
+    getFavorites: build.query<GetFavoritesResponse, GetFavoritesParams>({
+      query: ({ limit, page }) =>
+        buildClientRequestUrl(wishlist.getFavorites({ page, limit })),
+      providesTags: ['Favorite']
+    }),
+    addFavorite: build.mutation<AddFavoriteResponse, number>({
+      query: (productPk: number) => ({
+        url: buildClientRequestUrl(wishlist.addFavorite, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          product: productPk
+        }
+      }),
+      invalidatesTags: ['Favorite']
+    }),
+    removeFavorite: build.mutation<RemoteFavoriteResponse, number>({
+      query: (favPk: number) => ({
+        url: buildClientRequestUrl(wishlist.removeFavorite(favPk)),
+        method: 'DELETE'
+      }),
+      invalidatesTags: ['Favorite']
+    }),
+    // TODO: Add stock alert response type
+    addStockAlert: build.mutation<any, number>({
+      query: (productPk: number) => ({
+        url: buildClientRequestUrl(wishlist.addStockAlert, {
+          useFormData: true,
+          contentType: 'application/json'
+        }),
+        method: 'POST',
+        body: {
+          product: productPk
+        }
+      })
+    })
+  }),
+  overrideExisting: true
+});
+
+export const {
+  useGetFavoritesQuery,
+  useAddFavoriteMutation,
+  useRemoveFavoriteMutation,
+  useAddStockAlertMutation
+} = wishlistApi;

package/data/server/category.ts

@@ -0,0 +1,121 @@
+import { GetCategoryResponse } from '../../types';
+import { generateCommerceSearchParams } from '../../utils';
+import appFetch, { FetchResponseType } from '../../utils/app-fetch';
+import { category, product } from '../urls';
+import { Cache, CacheKey } from '../../lib/cache';
+import { parse } from 'lossless-json';
+import logger from '../../utils/log';
+
+function getCategoryDataHandler(pk: number, searchParams?: URLSearchParams) {
+  return async function () {
+    const params = generateCommerceSearchParams(searchParams);
+
+    const rawData = await appFetch<string>(
+      `${category.getCategoryByPk(pk)}${params ? params : ''}`,
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      },
+      FetchResponseType.TEXT
+    );
+
+    let data: GetCategoryResponse;
+
+    try {
+      const numberValueParser = (value) => {
+        return String(value);
+      };
+
+      data = parse(
+        rawData,
+        undefined,
+        numberValueParser
+      ) as GetCategoryResponse;
+    } catch (error) {
+      logger.error('Error while parsing category data', {
+        handler: 'getCategoryDataHandler',
+        error,
+        rawData
+      });
+    }
+
+    const menuItemModel = data?.category?.menuitemmodel;
+
+    const breadcrumbData = await appFetch<any>(
+      product.breadcrumbUrl(menuItemModel),
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    return { data, breadcrumbData: breadcrumbData?.menu };
+  };
+}
+
+export const getCategoryData = ({
+  pk,
+  searchParams
+}: {
+  pk: number;
+  searchParams?: URLSearchParams;
+}) => {
+  return Cache.wrap(
+    CacheKey.Category(pk, searchParams),
+    getCategoryDataHandler(pk, searchParams),
+    {
+      expire: 300
+    }
+  );
+};
+
+function getCategoryBySlugDataHandler(slug: string) {
+  return async function () {
+    let rawData = await appFetch<string>(
+      category.getCategoryBySlug(slug),
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      },
+      FetchResponseType.TEXT
+    );
+
+    let data: GetCategoryResponse;
+
+    try {
+      const numberValueParser = (value) => {
+        return String(value);
+      };
+
+      data = parse(
+        rawData,
+        undefined,
+        numberValueParser
+      ) as GetCategoryResponse;
+    } catch (error) {
+      logger.error('Error while parsing category data', {
+        handler: 'getCategoryBySlugDataHandler',
+        error,
+        rawData
+      });
+    }
+
+    return data;
+  };
+}
+
+export const getCategoryBySlugData = async ({ slug }) => {
+  return Cache.wrap(
+    CacheKey.CategorySlug(slug),
+    getCategoryBySlugDataHandler(slug),
+    {
+      expire: 300
+    }
+  );
+};

package/data/server/flatpage.ts

@@ -0,0 +1,21 @@
+import { flatpage } from '../urls';
+import { FlatPage } from '../../types';
+import appFetch from '../../utils/app-fetch';
+import { Cache, CacheKey } from '../../lib/cache';
+
+const getFlatPageDataHandler = (pk: number) => {
+  return async function () {
+    const data = await appFetch<FlatPage>(flatpage.getFlatPageByPk(pk), {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return data;
+  };
+};
+
+export const getFlatPageData = ({ pk }: { pk: number }) => {
+  return Cache.wrap(CacheKey.FlatPage(pk), getFlatPageDataHandler(pk));
+};

package/data/server/index.ts

@@ -0,0 +1,8 @@
+export * from './list';
+export * from './category';
+export * from './product';
+export * from './flatpage';
+export * from './special-page';
+export * from './widget';
+export * from './seo';
+export * from './menu';

package/data/server/list.ts

@@ -0,0 +1,56 @@
+import { Cache, CacheKey } from '../../lib/cache';
+import { category } from '../urls';
+import { GetCategoryResponse } from '../../types';
+import { generateCommerceSearchParams } from '../../utils';
+import appFetch, { FetchResponseType } from '../../utils/app-fetch';
+import { parse } from 'lossless-json';
+import logger from '../../utils/log';
+
+const getListDataHandler = (searchParams: URLSearchParams) => {
+  return async function () {
+    const params = generateCommerceSearchParams(searchParams);
+
+    const rawData = await appFetch<string>(
+      `${category.list}${params}`,
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      },
+      FetchResponseType.TEXT
+    );
+
+    let data: GetCategoryResponse;
+
+    try {
+      const numberValueParser = (value) => {
+        return String(value);
+      };
+
+      data = parse(
+        rawData,
+        undefined,
+        numberValueParser
+      ) as GetCategoryResponse;
+    } catch (error) {
+      logger.error('Error while parsing list data', { error, rawData });
+    }
+
+    return data;
+  };
+};
+
+export const getListData = async ({
+  searchParams
+}: {
+  searchParams: URLSearchParams;
+}) => {
+  return Cache.wrap(
+    CacheKey.List(searchParams),
+    getListDataHandler(searchParams),
+    {
+      expire: 300
+    }
+  );
+};

package/data/server/menu.ts

@@ -0,0 +1,35 @@
+import { Cache, CacheKey } from '../../lib/cache';
+import { MenuItemType } from '../../types';
+import appFetch from '../../utils/app-fetch';
+import { misc } from '../urls';
+
+interface MenuResponse {
+  menu: MenuItemType[];
+}
+
+interface MenuHandlerParams {
+  depth?: number;
+  parent?: string;
+}
+
+const DEFAULT_DEPTH = 3;
+
+const getMenuHandler =
+  ({ depth, parent }: MenuHandlerParams = { depth: DEFAULT_DEPTH }) =>
+  async () => {
+    const response = await appFetch<MenuResponse>(misc.menus(depth, parent));
+
+    return response?.menu;
+  };
+
+/**
+ * Returns menu data.
+ *
+ * Default depth is 3
+ */
+export const getMenu = async (params?: MenuHandlerParams) => {
+  return Cache.wrap(
+    CacheKey.Menu(params?.depth ?? DEFAULT_DEPTH, params?.parent),
+    getMenuHandler(params)
+  );
+};

package/data/server/product.ts

@@ -0,0 +1,86 @@
+import { Cache, CacheKey } from '../../lib/cache';
+import { product } from '../urls';
+import {
+  BreadcrumbResultType,
+  ProductCategoryResult,
+  ProductResult
+} from '../../types';
+import appFetch from '../../utils/app-fetch';
+
+type GetProduct = {
+  pk: number;
+  searchParams?: URLSearchParams;
+  groupProduct?: boolean;
+};
+
+const getProductDataHandler = ({
+  pk,
+  searchParams,
+  groupProduct
+}: GetProduct) => {
+  return async function () {
+    let url = groupProduct
+      ? product.getGroupProductByPk(pk)
+      : product.getProductByPk(pk);
+
+    if (searchParams) {
+      url +=
+        '?' +
+        Object.keys(searchParams)
+          .map((key) => `${key}=${searchParams[key]}`)
+          .join('&');
+    }
+
+    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>(
+      categoryUrl,
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    const breadcrumbUrl = product.breadcrumbUrl(
+      productCategoryData.results[0].menuitemmodel
+    );
+
+    const breadcrumbData = await appFetch<any>(breadcrumbUrl, {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return {
+      data,
+      breadcrumbData: breadcrumbData?.menu
+    };
+  };
+};
+
+export const getProductData = async ({
+  pk,
+  searchParams,
+  groupProduct
+}: GetProduct) => {
+  return Cache.wrap(
+    CacheKey[groupProduct ? 'GroupProduct' : 'Product'](
+      pk,
+      searchParams ?? new URLSearchParams()
+    ),
+    getProductDataHandler({ pk, searchParams, groupProduct }),
+    {
+      expire: 300
+    }
+  );
+};