From bcbb22cc4c0160b31cb6e5d705f27e9ba53bab25 Mon Sep 17 00:00:00 2001
From: Cecilia Panicali <cecilia@f2.net>
Date: Mon, 19 Aug 2024 14:53:44 +0200
Subject: [PATCH] Multiple-backends first commit

---
 app/(frontend)/layout.tsx                   |   2 +-
 app/(frontend)/product/[handle]/page.tsx    |   2 +-
 app/(frontend)/search/[collection]/page.tsx |   2 +-
 app/(frontend)/search/layout.tsx            |   2 +-
 app/(frontend)/search/page.tsx              |   2 +-
 app/sitemap.ts                              |   2 +-
 components/cart/actions.ts                  |   2 +-
 components/cart/modal.tsx                   |   6 +-
 components/layout/navbar/search.tsx         |   4 +-
 components/layout/search/filter/index.tsx   |   2 +-
 components/layout/search/filter/item.tsx    |   4 +-
 lib/bigcommerce/constants.ts                |  62 ++
 lib/bigcommerce/fragments/cart.ts           | 187 ++++++
 lib/bigcommerce/fragments/page.ts           |  13 +
 lib/bigcommerce/fragments/product.ts        | 178 +++++
 lib/bigcommerce/index.ts                    | 696 ++++++++++++++++++++
 lib/bigcommerce/mappers.ts                  | 333 ++++++++++
 lib/bigcommerce/mutations/cart.ts           | 151 +++++
 lib/bigcommerce/queries/cart.ts             |  94 +++
 lib/bigcommerce/queries/category.ts         |  28 +
 lib/bigcommerce/queries/checkout.ts         |  20 +
 lib/bigcommerce/queries/menu.ts             |  21 +
 lib/bigcommerce/queries/page.ts             |  89 +++
 lib/bigcommerce/queries/product.ts          | 130 ++++
 lib/bigcommerce/queries/route.ts            |  35 +
 lib/bigcommerce/storefront-config.ts        |  45 ++
 lib/bigcommerce/type-guards.ts              |  27 +
 lib/bigcommerce/types.ts                    | 606 +++++++++++++++++
 lib/bigcommerce/utils.ts                    |  43 ++
 lib/medusa/constants.ts                     |  39 ++
 lib/medusa/helpers.ts                       |  46 ++
 lib/medusa/index.ts                         | 520 +++++++++++++++
 lib/medusa/type-guards.ts                   |  27 +
 lib/medusa/types.ts                         | 433 ++++++++++++
 lib/medusa/utils.ts                         |  31 +
 lib/{ => shopify}/constants.ts              |   0
 lib/shopify/index.ts                        |   6 +-
 lib/shopify/revalidate.ts                   |   2 +-
 lib/{ => shopify}/type-guards.ts            |   0
 lib/{ => shopify}/utils.ts                  |   0
 tsconfig.json                               |  21 +-
 41 files changed, 3880 insertions(+), 33 deletions(-)
 create mode 100644 lib/bigcommerce/constants.ts
 create mode 100644 lib/bigcommerce/fragments/cart.ts
 create mode 100644 lib/bigcommerce/fragments/page.ts
 create mode 100644 lib/bigcommerce/fragments/product.ts
 create mode 100644 lib/bigcommerce/index.ts
 create mode 100644 lib/bigcommerce/mappers.ts
 create mode 100644 lib/bigcommerce/mutations/cart.ts
 create mode 100644 lib/bigcommerce/queries/cart.ts
 create mode 100644 lib/bigcommerce/queries/category.ts
 create mode 100644 lib/bigcommerce/queries/checkout.ts
 create mode 100644 lib/bigcommerce/queries/menu.ts
 create mode 100644 lib/bigcommerce/queries/page.ts
 create mode 100644 lib/bigcommerce/queries/product.ts
 create mode 100644 lib/bigcommerce/queries/route.ts
 create mode 100644 lib/bigcommerce/storefront-config.ts
 create mode 100644 lib/bigcommerce/type-guards.ts
 create mode 100644 lib/bigcommerce/types.ts
 create mode 100644 lib/bigcommerce/utils.ts
 create mode 100644 lib/medusa/constants.ts
 create mode 100644 lib/medusa/helpers.ts
 create mode 100644 lib/medusa/index.ts
 create mode 100644 lib/medusa/type-guards.ts
 create mode 100644 lib/medusa/types.ts
 create mode 100644 lib/medusa/utils.ts
 rename lib/{ => shopify}/constants.ts (100%)
 rename lib/{ => shopify}/type-guards.ts (100%)
 rename lib/{ => shopify}/utils.ts (100%)

diff --git a/app/(frontend)/layout.tsx b/app/(frontend)/layout.tsx
index 8262b2e..0ce82b4 100644
--- a/app/(frontend)/layout.tsx
+++ b/app/(frontend)/layout.tsx
@@ -1,3 +1,4 @@
+import { ensureStartsWith } from '@/lib/shopify/utils';
 import config from '@/react-bricks/config';
 import { CartProvider } from 'components/cart/cart-context';
 import { Navbar } from 'components/layout/navbar';
@@ -8,7 +9,6 @@ import { ThemeProvider } from 'components/react-bricks/theme-provider';
 import { WelcomeToast } from 'components/welcome-toast';
 import { GeistSans } from 'geist/font/sans';
 import { getCart } from 'lib/shopify';
-import { ensureStartsWith } from 'lib/utils';
 import { cookies } from 'next/headers';
 import { ReactNode } from 'react';
 import { PageViewer, cleanPage, fetchPage, getBricks, register, types } from 'react-bricks/rsc';
diff --git a/app/(frontend)/product/[handle]/page.tsx b/app/(frontend)/product/[handle]/page.tsx
index a0a3542..3f79be8 100644
--- a/app/(frontend)/product/[handle]/page.tsx
+++ b/app/(frontend)/product/[handle]/page.tsx
@@ -5,7 +5,7 @@ import ErrorNoKeys from '@/components/react-bricks/error-no-keys';
 import ErrorNoPage from '@/components/react-bricks/error-no-page';
 import { Product } from '@/lib/shopify/types';
 import config from '@/react-bricks/config';
-import { HIDDEN_PRODUCT_TAG } from 'lib/constants';
+import { HIDDEN_PRODUCT_TAG } from '@/lib/shopify/constants';
 import { getProduct } from 'lib/shopify';
 import { cleanPage, fetchPage, getBricks, JsonLd, PageViewer, types } from 'react-bricks/rsc';
 import { ClickToEdit } from 'react-bricks/rsc/client';
diff --git a/app/(frontend)/search/[collection]/page.tsx b/app/(frontend)/search/[collection]/page.tsx
index e25542b..aad42d2 100644
--- a/app/(frontend)/search/[collection]/page.tsx
+++ b/app/(frontend)/search/[collection]/page.tsx
@@ -4,7 +4,7 @@ import { notFound } from 'next/navigation';
 
 import Grid from 'components/grid';
 import ProductGridItems from 'components/layout/product-grid-items';
-import { defaultSort, sorting } from 'lib/constants';
+import { defaultSort, sorting } from '@/lib/shopify/constants';
 
 export async function generateMetadata({
   params
diff --git a/app/(frontend)/search/layout.tsx b/app/(frontend)/search/layout.tsx
index 84cce22..2716e5a 100644
--- a/app/(frontend)/search/layout.tsx
+++ b/app/(frontend)/search/layout.tsx
@@ -1,6 +1,6 @@
 import Collections from 'components/layout/search/collections';
 import FilterList from 'components/layout/search/filter';
-import { sorting } from 'lib/constants';
+import { sorting } from '@/lib/shopify/constants';
 
 export default function SearchLayout({ children }: { children: React.ReactNode }) {
   return (
diff --git a/app/(frontend)/search/page.tsx b/app/(frontend)/search/page.tsx
index 60f11b1..8a5ff00 100644
--- a/app/(frontend)/search/page.tsx
+++ b/app/(frontend)/search/page.tsx
@@ -1,6 +1,6 @@
 import Grid from 'components/grid';
 import ProductGridItems from 'components/layout/product-grid-items';
-import { defaultSort, sorting } from 'lib/constants';
+import { defaultSort, sorting } from '@/lib/shopify/constants';
 import { getProducts } from 'lib/shopify';
 
 export const metadata = {
diff --git a/app/sitemap.ts b/app/sitemap.ts
index 8f31ee9..5cb4ecf 100644
--- a/app/sitemap.ts
+++ b/app/sitemap.ts
@@ -1,5 +1,5 @@
+import { validateEnvironmentVariables } from '@/lib/shopify/utils';
 import { getCollections, getPages, getProducts } from 'lib/shopify';
-import { validateEnvironmentVariables } from 'lib/utils';
 import { MetadataRoute } from 'next';
 
 type Route = {
diff --git a/components/cart/actions.ts b/components/cart/actions.ts
index a2c5925..5e3e031 100644
--- a/components/cart/actions.ts
+++ b/components/cart/actions.ts
@@ -1,6 +1,6 @@
 'use server';
 
-import { TAGS } from 'lib/constants';
+import { TAGS } from '@/lib/shopify/constants';
 import { addToCart, createCart, getCart, removeFromCart, updateCart } from 'lib/shopify';
 import { revalidateTag } from 'next/cache';
 import { cookies } from 'next/headers';
diff --git a/components/cart/modal.tsx b/components/cart/modal.tsx
index ca1e346..59cf244 100644
--- a/components/cart/modal.tsx
+++ b/components/cart/modal.tsx
@@ -1,11 +1,11 @@
 'use client';
 
+import { createUrl } from '@/lib/shopify/utils';
 import { Dialog, Transition } from '@headlessui/react';
 import { ShoppingCartIcon } from '@heroicons/react/24/outline';
 import LoadingDots from 'components/loading-dots';
 import Price from 'components/price';
-import { DEFAULT_OPTION } from 'lib/constants';
-import { createUrl } from 'lib/utils';
+import { DEFAULT_OPTION } from '@/lib/shopify/constants';
 import Image from 'next/image';
 import Link from 'next/link';
 import { Fragment, useEffect, useRef, useState } from 'react';
@@ -74,7 +74,7 @@ export default function CartModal() {
             leaveFrom="translate-x-0"
             leaveTo="translate-x-full"
           >
-            <Dialog.Panel className="fixed bottom-0 right-0 top-0 flex h-full w-full flex-col border-l border-neutral-200 bg-white/80 p-6 text-black backdrop-blur-xl md:w-[390px] dark:border-neutral-700 dark:bg-black/80 dark:text-white">
+            <Dialog.Panel className="fixed bottom-0 right-0 top-0 flex h-full w-full flex-col border-l border-neutral-200 bg-white/80 p-6 text-black backdrop-blur-xl dark:border-neutral-700 dark:bg-black/80 dark:text-white md:w-[390px]">
               <div className="flex items-center justify-between">
                 <p className="text-lg font-semibold">My Cart</p>
                 <button aria-label="Close cart" onClick={closeCart}>
diff --git a/components/layout/navbar/search.tsx b/components/layout/navbar/search.tsx
index 10286c0..3dcbc64 100644
--- a/components/layout/navbar/search.tsx
+++ b/components/layout/navbar/search.tsx
@@ -1,7 +1,7 @@
 'use client';
 
+import { createUrl } from '@/lib/shopify/utils';
 import { MagnifyingGlassIcon } from '@heroicons/react/24/outline';
-import { createUrl } from 'lib/utils';
 import { useRouter, useSearchParams } from 'next/navigation';
 
 export default function Search() {
@@ -33,7 +33,7 @@ export default function Search() {
         placeholder="Search for products..."
         autoComplete="off"
         defaultValue={searchParams?.get('q') || ''}
-        className="text-md w-full rounded-lg border bg-white px-4 py-2 text-black placeholder:text-neutral-500 md:text-sm dark:border-neutral-800 dark:bg-transparent dark:text-white dark:placeholder:text-neutral-400"
+        className="text-md w-full rounded-lg border bg-white px-4 py-2 text-black placeholder:text-neutral-500 dark:border-neutral-800 dark:bg-transparent dark:text-white dark:placeholder:text-neutral-400 md:text-sm"
       />
       <div className="absolute right-0 top-0 mr-3 flex h-full items-center">
         <MagnifyingGlassIcon className="h-4" />
diff --git a/components/layout/search/filter/index.tsx b/components/layout/search/filter/index.tsx
index 11a7cd3..e705bc5 100644
--- a/components/layout/search/filter/index.tsx
+++ b/components/layout/search/filter/index.tsx
@@ -1,4 +1,4 @@
-import { SortFilterItem } from 'lib/constants';
+import { SortFilterItem } from '@/lib/shopify/constants';
 import { Suspense } from 'react';
 import FilterItemDropdown from './dropdown';
 import { FilterItem } from './item';
diff --git a/components/layout/search/filter/item.tsx b/components/layout/search/filter/item.tsx
index 3fce8e8..8709789 100644
--- a/components/layout/search/filter/item.tsx
+++ b/components/layout/search/filter/item.tsx
@@ -1,8 +1,8 @@
 'use client';
 
+import { createUrl } from '@/lib/shopify/utils';
 import clsx from 'clsx';
-import type { SortFilterItem } from 'lib/constants';
-import { createUrl } from 'lib/utils';
+import type { SortFilterItem } from '@/lib/shopify/constants';
 import Link from 'next/link';
 import { usePathname, useSearchParams } from 'next/navigation';
 import type { ListItem, PathFilterItem } from '.';
diff --git a/lib/bigcommerce/constants.ts b/lib/bigcommerce/constants.ts
new file mode 100644
index 0000000..0361c6f
--- /dev/null
+++ b/lib/bigcommerce/constants.ts
@@ -0,0 +1,62 @@
+export const BIGCOMMERCE_API_URL = process.env.BIGCOMMERCE_API_URL ?? 'https://api.bigcommerce.com';
+export const BIGCOMMERCE_CANONICAL_STORE_DOMAIN =
+  process.env.BIGCOMMERCE_CANONICAL_STORE_DOMAIN ?? 'mybigcommerce.com';
+export const BIGCOMMERCE_GRAPHQL_API_ENDPOINT = `${BIGCOMMERCE_CANONICAL_STORE_DOMAIN}/graphql`;
+
+export enum BigCommerceSortKeys {
+  A_TO_Z = 'A_TO_Z',
+  BEST_REVIEWED = 'BEST_REVIEWED',
+  BEST_SELLING = 'BEST_SELLING',
+  RELEVANCE = 'RELEVANCE',
+  FEATURED = 'FEATURED',
+  HIGHEST_PRICE = 'HIGHEST_PRICE',
+  LOWEST_PRICE = 'LOWEST_PRICE',
+  NEWEST = 'NEWEST',
+  Z_TO_A = 'Z_TO_A'
+}
+
+export enum VercelSortKeys {
+  RELEVANCE = 'RELEVANCE',
+  BEST_SELLING = 'BEST_SELLING',
+  CREATED_AT = 'CREATED_AT',
+  PRICE = 'PRICE'
+}
+
+export enum vercelToBigCommerceSortKeys {
+  RELEVANCE = 'RELEVANCE',
+  BEST_SELLING = 'BEST_SELLING',
+  CREATED_AT = 'NEWEST',
+  PRICE = 'LOWEST_PRICE',
+  PRICE_ON_REVERSE = 'HIGHEST_PRICE'
+}
+
+export type SortFilterItem = {
+  title: string;
+  slug: string | null;
+  sortKey: keyof typeof VercelSortKeys;
+  reverse: boolean;
+};
+
+export const defaultSort: SortFilterItem = {
+  title: 'Relevance',
+  slug: null,
+  sortKey: 'RELEVANCE',
+  reverse: false
+};
+
+export const sorting: SortFilterItem[] = [
+  defaultSort,
+  { title: 'Trending', slug: 'trending-desc', sortKey: 'BEST_SELLING', reverse: false }, // asc
+  { title: 'Latest arrivals', slug: 'latest-desc', sortKey: 'CREATED_AT', reverse: true },
+  { title: 'Price: Low to high', slug: 'price-asc', sortKey: 'PRICE', reverse: false }, // asc
+  { title: 'Price: High to low', slug: 'price-desc', sortKey: 'PRICE', reverse: true }
+];
+
+export const TAGS = {
+  collections: 'collections',
+  products: 'products',
+  cart: 'cart'
+};
+
+export const HIDDEN_PRODUCT_TAG = 'nextjs-frontend-hidden';
+export const DEFAULT_OPTION = 'Default Title';
\ No newline at end of file
diff --git a/lib/bigcommerce/fragments/cart.ts b/lib/bigcommerce/fragments/cart.ts
new file mode 100644
index 0000000..67a7623
--- /dev/null
+++ b/lib/bigcommerce/fragments/cart.ts
@@ -0,0 +1,187 @@
+const physicalItemFragment = /* GraphQL */ `
+  fragment physicalItem on CartPhysicalItem {
+    entityId
+    parentEntityId
+    variantEntityId
+    productEntityId
+    sku
+    name
+    url
+    imageUrl
+    brand
+    quantity
+    isTaxable
+    discounts {
+      entityId
+      discountedAmount {
+        currencyCode
+        value
+      }
+    }
+    discountedAmount {
+      currencyCode
+      value
+    }
+    couponAmount {
+      currencyCode
+      value
+    }
+    listPrice {
+      currencyCode
+      value
+    }
+    originalPrice {
+      currencyCode
+      value
+    }
+    salePrice {
+      currencyCode
+      value
+    }
+    extendedListPrice {
+      currencyCode
+      value
+    }
+    extendedSalePrice {
+      currencyCode
+      value
+    }
+    isShippingRequired
+    selectedOptions {
+      entityId
+      name
+      ... on CartSelectedCheckboxOption {
+        value
+        valueEntityId
+      }
+      ... on CartSelectedDateFieldOption {
+        date {
+          utc
+        }
+      }
+      ... on CartSelectedFileUploadOption {
+        fileName
+      }
+      ... on CartSelectedMultiLineTextFieldOption {
+        text
+      }
+      ... on CartSelectedMultipleChoiceOption {
+        value
+        valueEntityId
+      }
+      ... on CartSelectedNumberFieldOption {
+        number
+      }
+      ... on CartSelectedTextFieldOption {
+        text
+      }
+    }
+    giftWrapping {
+      name
+      amount {
+        currencyCode
+        value
+      }
+      message
+    }
+  }
+`;
+
+const digitalItemFragment = /* GraphQL */ `
+  fragment digitalItem on CartDigitalItem {
+    entityId
+    parentEntityId
+    variantEntityId
+    productEntityId
+    sku
+    name
+    url
+    imageUrl
+    brand
+    quantity
+    isTaxable
+    discounts {
+      entityId
+      discountedAmount {
+        currencyCode
+        value
+      }
+    }
+    discountedAmount {
+      currencyCode
+      value
+    }
+    couponAmount {
+      currencyCode
+      value
+    }
+    listPrice {
+      currencyCode
+      value
+    }
+    originalPrice {
+      currencyCode
+      value
+    }
+    salePrice {
+      currencyCode
+      value
+    }
+    extendedListPrice {
+      currencyCode
+      value
+    }
+    extendedSalePrice {
+      currencyCode
+      value
+    }
+    selectedOptions {
+      entityId
+      name
+      ... on CartSelectedCheckboxOption {
+        value
+        valueEntityId
+      }
+      ... on CartSelectedDateFieldOption {
+        date {
+          utc
+        }
+      }
+      ... on CartSelectedFileUploadOption {
+        fileName
+      }
+      ... on CartSelectedMultiLineTextFieldOption {
+        text
+      }
+      ... on CartSelectedMultipleChoiceOption {
+        value
+        valueEntityId
+      }
+      ... on CartSelectedNumberFieldOption {
+        number
+      }
+      ... on CartSelectedTextFieldOption {
+        text
+      }
+    }
+  }
+`;
+
+const customItemFragment = /* GraphQL */ `
+  fragment customItem on CartCustomItem {
+    entityId
+    sku
+    name
+    quantity
+    extendedListPrice {
+      currencyCode
+      value
+    }
+    listPrice {
+      value
+      currencyCode
+    }
+  }
+`;
+
+export { customItemFragment, digitalItemFragment, physicalItemFragment };
diff --git a/lib/bigcommerce/fragments/page.ts b/lib/bigcommerce/fragments/page.ts
new file mode 100644
index 0000000..3d5c12b
--- /dev/null
+++ b/lib/bigcommerce/fragments/page.ts
@@ -0,0 +1,13 @@
+export const pageContentFragment = /* GraphQL */ `
+  fragment pageContent on WebPage {
+    __typename
+    entityId
+    isVisibleInNavigation
+    name
+    seo {
+      metaKeywords
+      metaDescription
+      pageTitle
+    }
+  }
+`;
diff --git a/lib/bigcommerce/fragments/product.ts b/lib/bigcommerce/fragments/product.ts
new file mode 100644
index 0000000..eca7d19
--- /dev/null
+++ b/lib/bigcommerce/fragments/product.ts
@@ -0,0 +1,178 @@
+const productOptionFragment = /* GraphQL */ `
+  fragment productOption on CatalogProductOption {
+    __typename
+    entityId
+    displayName
+    isRequired
+    ... on MultipleChoiceOption {
+      displayStyle
+      values(first: 5) {
+        edges {
+          node {
+            entityId
+            isDefault
+            ... on SwatchOptionValue {
+              hexColors
+              imageUrl(width: 200)
+              label
+              isSelected
+            }
+            ... on MultipleChoiceOptionValue {
+              entityId
+              label
+              isSelected
+            }
+            ... on ProductPickListOptionValue {
+              entityId
+              label
+              isSelected
+            }
+          }
+        }
+      }
+    }
+    ... on NumberFieldOption {
+      entityId
+      displayName
+    }
+    ... on TextFieldOption {
+      entityId
+      displayName
+    }
+    ... on MultiLineTextFieldOption {
+      entityId
+      displayName
+    }
+    ... on FileUploadFieldOption {
+      entityId
+      displayName
+    }
+    ... on DateFieldOption {
+      entityId
+      displayName
+    }
+    ... on CheckboxOption {
+      entityId
+      displayName
+    }
+  }
+`;
+
+const productVariantFragment = /* GraphQL */ `
+  fragment productVariant on Variant {
+    id
+    entityId
+    sku
+    upc
+    isPurchasable
+    prices {
+      price {
+        value
+        currencyCode
+      }
+      priceRange {
+        min {
+          value
+          currencyCode
+        }
+        max {
+          value
+          currencyCode
+        }
+      }
+    }
+    options(first: 5) {
+      edges {
+        node {
+          entityId
+          displayName
+          values(first: 5) {
+            edges {
+              node {
+                entityId
+                label
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+const productFragment = /* GraphQL */ `
+  fragment product on Product {
+    id
+    entityId
+    sku
+    upc
+    name
+    brand {
+      name
+    }
+    plainTextDescription
+    description
+    availabilityV2 {
+      status
+      description
+    }
+    defaultImage {
+      ...ImageFields
+    }
+    images {
+      edges {
+        node {
+          ...ImageFields
+        }
+      }
+    }
+    seo {
+      pageTitle
+      metaDescription
+      metaKeywords
+    }
+    path
+    prices {
+      price {
+        ...MoneyFields
+      }
+      priceRange {
+        min {
+          ...MoneyFields
+        }
+        max {
+          ...MoneyFields
+        }
+      }
+    }
+    createdAt {
+      utc
+    }
+    variants(first: 5) {
+      edges {
+        node {
+          ...productVariant
+        }
+      }
+    }
+    productOptions(first: 3) {
+      edges {
+        node {
+          ...productOption
+        }
+      }
+    }
+  }
+  fragment ImageFields on Image {
+    url: url(width: 1080)
+    altText
+  }
+  fragment MoneyFields on Money {
+    value
+    currencyCode
+  }
+  ${productOptionFragment}
+  ${productVariantFragment}
+`;
+
+export { productFragment, productOptionFragment, productVariantFragment };
diff --git a/lib/bigcommerce/index.ts b/lib/bigcommerce/index.ts
new file mode 100644
index 0000000..3f4a27c
--- /dev/null
+++ b/lib/bigcommerce/index.ts
@@ -0,0 +1,696 @@
+import { isVercelCommerceError } from './type-guards';
+import { notFound } from 'next/navigation';
+import { NextRequest, NextResponse } from 'next/server';
+import { BIGCOMMERCE_GRAPHQL_API_ENDPOINT } from './constants';
+
+import {
+  bigCommerceToVercelCart,
+  bigCommerceToVercelCollection,
+  bigCommerceToVercelPageContent,
+  bigCommerceToVercelProduct,
+  bigCommerceToVercelProducts,
+  vercelFromBigCommerceLineItems,
+  vercelToBigCommerceSorting
+} from './mappers';
+import {
+  addCartLineItemMutation,
+  createCartMutation,
+  deleteCartLineItemMutation,
+  updateCartLineItemMutation
+} from './mutations/cart';
+import { getCartQuery } from './queries/cart';
+import { getCategoryQuery, getStoreCategoriesQuery } from './queries/category';
+import { getCheckoutQuery } from './queries/checkout';
+import { getMenuQuery } from './queries/menu';
+import { getPageQuery, getPagesQuery } from './queries/page';
+import {
+  getFeaturedProductsQuery,
+  getNewestProductsQuery,
+  getProductQuery,
+  getProductsCollectionQuery,
+  getProductsRecommedationsQuery,
+  getStoreProductsQuery,
+  searchProductsQuery
+} from './queries/product';
+import { getEntityIdByRouteQuery } from './queries/route';
+import { memoizedCartRedirectUrl } from './storefront-config';
+import {
+  BigCommerceAddToCartOperation,
+  BigCommerceCart,
+  BigCommerceCartOperation,
+  BigCommerceCategoryTreeItem,
+  BigCommerceCheckoutOperation,
+  BigCommerceCollectionOperation,
+  BigCommerceCollectionsOperation,
+  BigCommerceCreateCartOperation,
+  BigCommerceDeleteCartItemOperation,
+  BigCommerceEntityIdOperation,
+  BigCommerceFeaturedProductsOperation,
+  BigCommerceMenuOperation,
+  BigCommerceNewestProductsOperation,
+  BigCommercePage,
+  BigCommercePageOperation,
+  BigCommercePagesOperation,
+  BigCommerceProduct,
+  BigCommerceProductOperation,
+  BigCommerceProductsCollectionOperation,
+  BigCommerceProductsOperation,
+  BigCommerceRecommendationsOperation,
+  BigCommerceSearchProductsOperation,
+  BigCommerceUpdateCartItemOperation,
+  VercelCart,
+  VercelCollection,
+  VercelMenu,
+  VercelPage,
+  VercelProduct
+} from './types';
+
+const channelIdSegment =
+  parseInt(process.env.BIGCOMMERCE_CHANNEL_ID!) !== 1
+    ? `-${process.env.BIGCOMMERCE_CHANNEL_ID}`
+    : '';
+const domain = `https://store-${process.env.BIGCOMMERCE_STORE_HASH!}${channelIdSegment}`;
+const endpoint = `${domain}.${BIGCOMMERCE_GRAPHQL_API_ENDPOINT}`;
+
+type ExtractVariables<T> = T extends { variables: object } ? T['variables'] : never;
+
+const getEntityIdByHandle = async (entityHandle: string) => {
+  const res = await bigCommerceFetch<BigCommerceEntityIdOperation>({
+    query: getEntityIdByRouteQuery,
+    variables: {
+      path: `/${entityHandle}`
+    }
+  });
+
+  return res.body.data.site.route.node?.entityId;
+};
+
+export async function bigCommerceFetch<T>({
+  query,
+  variables,
+  headers,
+  cache = 'force-cache'
+}: {
+  query: string;
+  variables?: ExtractVariables<T>;
+  headers?: HeadersInit;
+  cache?: RequestCache;
+}): Promise<{ status: number; body: T } | never> {
+  try {
+    const result = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${process.env.BIGCOMMERCE_CUSTOMER_IMPERSONATION_TOKEN}`,
+        'Content-Type': 'application/json',
+        ...headers
+      },
+      body: JSON.stringify({
+        ...(query && { query }),
+        ...(variables && { variables })
+      }),
+      cache
+    });
+
+    const body = await result.json();
+
+    if (body.errors) {
+      throw body.errors[0];
+    }
+
+    return {
+      status: result.status,
+      body
+    };
+  } catch (e) {
+    if (isVercelCommerceError(e)) {
+      throw {
+        status: e.status || 500,
+        message: e.message,
+        query
+      };
+    }
+
+    throw {
+      error: e,
+      query
+    };
+  }
+}
+
+const getCategoryEntityIdbyHandle = async (handle: string) => {
+  const resp = await bigCommerceFetch<BigCommerceMenuOperation>({
+    query: getMenuQuery
+  });
+  const recursiveFindCollectionId = (list: BigCommerceCategoryTreeItem[], slug: string): number => {
+    const collectionId = list
+      .flatMap((item): number | null => {
+        if (item.path.includes(slug!)) {
+          return item.entityId;
+        }
+
+        if (item.children && item.children.length) {
+          return recursiveFindCollectionId(item.children!, slug);
+        }
+
+        return null;
+      })
+      .filter((id) => typeof id === 'number')[0];
+
+    return collectionId!;
+  };
+
+  return recursiveFindCollectionId(resp.body.data.site.categoryTree, handle);
+};
+
+const getBigCommerceProductsWithCheckout = async (
+  cartId: string,
+  lines: { merchandiseId: string; quantity: number; productId?: string }[]
+) => {
+  const productIds = lines.map(({ merchandiseId, productId }) =>
+    parseInt(productId ?? merchandiseId, 10)
+  );
+  const bigCommerceProductListRes = await bigCommerceFetch<BigCommerceProductsOperation>({
+    query: getStoreProductsQuery,
+    variables: {
+      entityIds: productIds
+    },
+    cache: 'no-store'
+  });
+  const bigCommerceProductList = bigCommerceProductListRes.body.data.site.products.edges.map(
+    (product) => product.node
+  );
+
+  const createProductList = (idList: number[], products: BigCommerceProduct[]) => {
+    return idList.map((productId) => {
+      const productData = products.find(({ entityId }) => entityId === productId)!;
+
+      return {
+        productId,
+        productData
+      };
+    });
+  };
+  const bigCommerceProducts = createProductList(productIds, bigCommerceProductList);
+
+  const resCheckout = await bigCommerceFetch<BigCommerceCheckoutOperation>({
+    query: getCheckoutQuery,
+    variables: {
+      entityId: cartId
+    },
+    cache: 'no-store'
+  });
+  const checkout = resCheckout.body.data.site.checkout ?? {
+    subtotal: {
+      value: 0,
+      currencyCode: ''
+    },
+    grandTotal: {
+      value: 0,
+      currencyCode: ''
+    },
+    taxTotal: {
+      value: 0,
+      currencyCode: ''
+    }
+  };
+
+  const checkoutUrlRes = await memoizedCartRedirectUrl(cartId);
+  const checkoutUrl = checkoutUrlRes.data?.embedded_checkout_url;
+
+  return {
+    productsByIdList: bigCommerceProducts,
+    checkoutUrl,
+    checkout
+  };
+};
+
+export async function createCart(): Promise<VercelCart> {
+  // NOTE: on BigCommerce side we can't create cart
+  // w/t item params as quantity, productEntityId
+  return {
+    id: '',
+    checkoutUrl: '',
+    cost: {
+      subtotalAmount: {
+        amount: '',
+        currencyCode: ''
+      },
+      totalAmount: {
+        amount: '',
+        currencyCode: ''
+      },
+      totalTaxAmount: {
+        amount: '',
+        currencyCode: ''
+      }
+    },
+    lines: [],
+    totalQuantity: 0
+  };
+}
+
+export async function addToCart(
+  cartId: string,
+  lines: { merchandiseId: string; quantity: number; productId?: string }[]
+): Promise<VercelCart> {
+  let bigCommerceCart: BigCommerceCart;
+
+  if (cartId) {
+    const res = await bigCommerceFetch<BigCommerceAddToCartOperation>({
+      query: addCartLineItemMutation,
+      variables: {
+        addCartLineItemsInput: {
+          cartEntityId: cartId,
+          data: {
+            lineItems: lines.map(({ merchandiseId, quantity, productId }) => ({
+              productEntityId: parseInt(productId!, 10),
+              variantEntityId: parseInt(merchandiseId, 10),
+              quantity
+            }))
+          }
+        }
+      },
+      cache: 'no-store'
+    });
+
+    bigCommerceCart = res.body.data.cart.addCartLineItems.cart;
+  } else {
+    const res = await bigCommerceFetch<BigCommerceCreateCartOperation>({
+      query: createCartMutation,
+      variables: {
+        createCartInput: {
+          lineItems: lines.map(({ merchandiseId, quantity, productId }) => ({
+            productEntityId: parseInt(productId!, 10),
+            variantEntityId: parseInt(merchandiseId, 10),
+            quantity
+          }))
+        }
+      },
+      cache: 'no-store'
+    });
+
+    bigCommerceCart = res.body.data.cart.createCart.cart;
+  }
+
+  const { productsByIdList, checkout, checkoutUrl } = await getBigCommerceProductsWithCheckout(
+    bigCommerceCart.entityId,
+    lines
+  );
+
+  return bigCommerceToVercelCart(bigCommerceCart, productsByIdList, checkout, checkoutUrl);
+}
+
+export async function removeFromCart(
+  cartId: string,
+  lineIds: string[]
+): Promise<VercelCart | undefined> {
+  let cartState: { status: number; body: BigCommerceDeleteCartItemOperation };
+  const removeCartItem = async (itemId: string) => {
+    const res = await bigCommerceFetch<BigCommerceDeleteCartItemOperation>({
+      query: deleteCartLineItemMutation,
+      variables: {
+        deleteCartLineItemInput: {
+          cartEntityId: cartId,
+          lineItemEntityId: itemId
+        }
+      },
+      cache: 'no-store'
+    });
+
+    return res;
+  };
+
+  if (lineIds.length === 1) {
+    cartState = await removeCartItem(lineIds[0]!);
+  } else if (lineIds.length > 1) {
+    // NOTE: can it happen at all??
+    let operations = lineIds.length;
+
+    while (operations > 0) {
+      operations--;
+      cartState = await removeCartItem(lineIds[operations]!);
+    }
+  }
+
+  const cart = cartState!.body.data.cart.deleteCartLineItem.cart;
+
+  if (cart === null) {
+    return undefined;
+  }
+
+  const lines = vercelFromBigCommerceLineItems(cart.lineItems);
+  const { productsByIdList, checkout, checkoutUrl } = await getBigCommerceProductsWithCheckout(
+    cartId,
+    lines
+  );
+
+  return bigCommerceToVercelCart(cart, productsByIdList, checkout, checkoutUrl);
+}
+
+// NOTE: update happens on product & variant levels w/t optionEntityId
+export async function updateCart(
+  cartId: string,
+  lines: { id: string; merchandiseId: string; quantity: number; productSlug?: string }[]
+): Promise<VercelCart> {
+  let cartState: { status: number; body: BigCommerceUpdateCartItemOperation } | undefined;
+
+  for (let updates = lines.length; updates > 0; updates--) {
+    const { id, merchandiseId, quantity, productSlug } = lines[updates - 1]!;
+    const productEntityId = (await getProductIdBySlug(productSlug!))?.entityId!;
+
+    const res = await bigCommerceFetch<BigCommerceUpdateCartItemOperation>({
+      query: updateCartLineItemMutation,
+      variables: {
+        updateCartLineItemInput: {
+          cartEntityId: cartId,
+          lineItemEntityId: id,
+          data: {
+            lineItem: {
+              variantEntityId: parseInt(merchandiseId, 10),
+              productEntityId,
+              quantity
+            }
+          }
+        }
+      },
+      cache: 'no-store'
+    });
+
+    cartState = res;
+  }
+
+  const updatedCart = cartState!.body.data.cart.updateCartLineItem.cart;
+  const { productsByIdList, checkout, checkoutUrl } = await getBigCommerceProductsWithCheckout(
+    cartId,
+    lines
+  );
+
+  return bigCommerceToVercelCart(updatedCart, productsByIdList, checkout, checkoutUrl);
+}
+
+export async function getCart(cartId: string): Promise<VercelCart | undefined> {
+  const res = await bigCommerceFetch<BigCommerceCartOperation>({
+    query: getCartQuery,
+    variables: { entityId: cartId },
+    cache: 'no-store'
+  });
+
+  if (!res.body.data.site.cart) {
+    return undefined;
+  }
+
+  const cart = res.body.data.site.cart;
+  const lines = vercelFromBigCommerceLineItems(cart.lineItems);
+  const { productsByIdList, checkout, checkoutUrl } = await getBigCommerceProductsWithCheckout(
+    cartId,
+    lines
+  );
+
+  return bigCommerceToVercelCart(cart, productsByIdList, checkout, checkoutUrl);
+}
+
+export async function getCollection(handle: string): Promise<VercelCollection> {
+  const entityId = await getCategoryEntityIdbyHandle(handle);
+  const res = await bigCommerceFetch<BigCommerceCollectionOperation>({
+    query: getCategoryQuery,
+    variables: {
+      entityId
+    }
+  });
+
+  return bigCommerceToVercelCollection(res.body.data.site.category);
+}
+
+export async function getCollectionProducts({
+  collection,
+  reverse,
+  sortKey
+}: {
+  collection: string;
+  reverse?: boolean;
+  sortKey?: string;
+}): Promise<VercelProduct[]> {
+  const expectedCollectionBreakpoints: Record<string, string> = {
+    'hidden-homepage-carousel': 'carousel_collection',
+    'hidden-homepage-featured-items': 'featured_collection'
+  };
+
+  if (expectedCollectionBreakpoints[collection] === 'carousel_collection') {
+    const res = await bigCommerceFetch<BigCommerceNewestProductsOperation>({
+      query: getNewestProductsQuery,
+      variables: {
+        first: 10
+      }
+    });
+
+    if (!res.body.data.site.newestProducts) {
+      console.log(`No collection found for \`${collection}\``);
+      return [];
+    }
+    const productList = res.body.data.site.newestProducts.edges.map((item) => item.node);
+
+    return bigCommerceToVercelProducts(productList);
+  }
+
+  if (expectedCollectionBreakpoints[collection] === 'featured_collection') {
+    const res = await bigCommerceFetch<BigCommerceFeaturedProductsOperation>({
+      query: getFeaturedProductsQuery,
+      variables: {
+        first: 10
+      }
+    });
+
+    if (!res.body.data.site.featuredProducts) {
+      console.log(`No collection found for \`${collection}\``);
+      return [];
+    }
+    const productList = res.body.data.site.featuredProducts.edges.map((item) => item.node);
+
+    return bigCommerceToVercelProducts(productList);
+  }
+
+  const entityId = await getCategoryEntityIdbyHandle(collection);
+  const sortBy = vercelToBigCommerceSorting(reverse ?? false, sortKey);
+  const res = await bigCommerceFetch<BigCommerceProductsCollectionOperation>({
+    query: getProductsCollectionQuery,
+    variables: {
+      entityId,
+      first: 10,
+      hideOutOfStock: false,
+      sortBy: sortBy === 'RELEVANCE' ? 'DEFAULT' : sortBy
+    }
+  });
+
+  if (!res.body.data.site.category) {
+    console.log(`No collection found for \`${collection}\``);
+    return [];
+  }
+  const productList = res.body.data.site.category.products.edges.map((item) => item.node);
+
+  return bigCommerceToVercelProducts(productList);
+}
+
+export async function getCollections(): Promise<VercelCollection[]> {
+  const res = await bigCommerceFetch<BigCommerceCollectionsOperation>({
+    query: getStoreCategoriesQuery
+  });
+  const collectionIdList = res.body.data.site.categoryTree.map(({ entityId }) => entityId);
+  const collections = await Promise.all(
+    collectionIdList.map(async (entityId) => {
+      const res = await bigCommerceFetch<BigCommerceCollectionOperation>({
+        query: getCategoryQuery,
+        variables: {
+          entityId
+        }
+      });
+      return bigCommerceToVercelCollection(res.body.data.site.category);
+    })
+  );
+
+  return collections;
+}
+
+export async function getMenu(handle: string): Promise<VercelMenu[]> {
+  const configureMenuPath = (path: string) =>
+    path
+      .split('/')
+      .filter((item) => item.length)
+      .pop();
+  const createVercelCollectionPath = (title: string, menuType: 'footer' | 'header') =>
+    menuType === 'header' ? `/search/${title}` : `/${title}`;
+  const configureVercelMenu = (
+    menuData: BigCommerceCategoryTreeItem[] | BigCommercePage[],
+    isMenuData: boolean,
+    menuType?: 'footer' | 'header'
+  ): VercelMenu[] => {
+    if (isMenuData) {
+      return menuData
+        .flatMap((item) => {
+          let vercelMenuItem;
+
+          if (menuType === 'header') {
+            const { name, path, hasChildren, children } = item as BigCommerceCategoryTreeItem;
+            const vercelTitle = configureMenuPath(path ?? '');
+            // NOTE: keep only high level categories for NavBar
+            // if (hasChildren && children) {
+            //   return configureVercelMenu(children, hasChildren);
+            // }
+
+            vercelMenuItem = {
+              title: name,
+              path: createVercelCollectionPath(vercelTitle!, menuType ?? 'header')
+            };
+
+            return [vercelMenuItem];
+          }
+
+          if (menuType === 'footer') {
+            const { isVisibleInNavigation, name, path } = item as BigCommercePage;
+            const vercelTitle = configureMenuPath(path ?? '');
+
+            vercelMenuItem = {
+              title: name,
+              path: createVercelCollectionPath(vercelTitle!, menuType ?? 'footer')
+            };
+            // NOTE: blog has different structure & separate mapper
+            return vercelMenuItem.title === 'Blog' || !isVisibleInNavigation
+              ? []
+              : [vercelMenuItem];
+          }
+
+          return [];
+        })
+        .slice(0, 4);
+    }
+
+    return [];
+  };
+
+  if (handle === 'next-js-frontend-footer-menu') {
+    const res = await bigCommerceFetch<BigCommercePagesOperation>({
+      query: getPagesQuery
+    });
+    const webPages = res.body.data.site.content.pages.edges.map((item) => item.node);
+
+    return configureVercelMenu(webPages, true, 'footer');
+  }
+
+  if (handle === 'next-js-frontend-header-menu') {
+    const res = await bigCommerceFetch<BigCommerceMenuOperation>({
+      query: getMenuQuery
+    });
+
+    return configureVercelMenu(res.body.data.site.categoryTree, true, 'header');
+  }
+
+  return [];
+}
+
+export async function getPage(handle: string): Promise<VercelPage> {
+  const entityId = await getEntityIdByHandle(handle);
+
+  if (!entityId) {
+    notFound();
+  }
+
+  const res = await bigCommerceFetch<BigCommercePageOperation>({
+    query: getPageQuery,
+    variables: {
+      entityId
+    }
+  });
+
+  return bigCommerceToVercelPageContent(res.body.data.site.content.page);
+}
+
+export async function getPages(): Promise<VercelPage[]> {
+  const res = await bigCommerceFetch<BigCommercePagesOperation>({
+    query: getPagesQuery
+  });
+
+  const pagesList = res.body.data.site.content.pages.edges.map((item) => item.node);
+
+  return pagesList.map((page) => bigCommerceToVercelPageContent(page));
+}
+
+export async function getProduct(handle: string): Promise<VercelProduct | undefined> {
+  const res = await bigCommerceFetch<BigCommerceProductOperation>({
+    query: getProductQuery,
+    variables: {
+      productId: parseInt(handle, 10)
+    }
+  });
+
+  return bigCommerceToVercelProduct(res.body.data.site.product);
+}
+
+export async function getProductIdBySlug(path: string): Promise<
+  | {
+      __typename:
+        | 'Product'
+        | 'Category'
+        | 'Brand'
+        | 'NormalPage'
+        | 'ContactPage'
+        | 'RawHtmlPage'
+        | 'BlogIndexPage';
+      entityId: number;
+    }
+  | undefined
+> {
+  const res = await bigCommerceFetch<BigCommerceEntityIdOperation>({
+    query: getEntityIdByRouteQuery,
+    variables: {
+      path
+    }
+  });
+
+  return res.body.data.site.route.node;
+}
+
+export async function getProductRecommendations(productId: string): Promise<VercelProduct[]> {
+  const res = await bigCommerceFetch<BigCommerceRecommendationsOperation>({
+    query: getProductsRecommedationsQuery,
+    variables: {
+      productId: productId
+    }
+  });
+
+  const productList = res.body.data.site.product.relatedProducts.edges.map((item) => item.node);
+
+  return bigCommerceToVercelProducts(productList);
+}
+
+export async function getProducts({
+  query,
+  reverse,
+  sortKey
+}: {
+  query?: string;
+  reverse?: boolean;
+  sortKey?: string;
+}): Promise<VercelProduct[]> {
+  const sort = vercelToBigCommerceSorting(reverse ?? false, sortKey);
+  const res = await bigCommerceFetch<BigCommerceSearchProductsOperation>({
+    query: searchProductsQuery,
+    variables: {
+      filters: {
+        searchTerm: query || ''
+      },
+      sort
+    }
+  });
+
+  const productList = res.body.data.site.search.searchProducts.products.edges.map(
+    (item) => item.node
+  );
+
+  return bigCommerceToVercelProducts(productList);
+}
+
+// This is called from `app/api/revalidate.ts` so providers can control revalidation logic.
+// eslint-disable-next-line no-unused-vars
+export async function revalidate(req: NextRequest): Promise<NextResponse> {
+  return NextResponse.json({ status: 200, revalidated: true, now: Date.now() });
+}
diff --git a/lib/bigcommerce/mappers.ts b/lib/bigcommerce/mappers.ts
new file mode 100644
index 0000000..6d75cf3
--- /dev/null
+++ b/lib/bigcommerce/mappers.ts
@@ -0,0 +1,333 @@
+import { BigCommerceSortKeys, VercelSortKeys, vercelToBigCommerceSortKeys } from './constants';
+import {
+  BigCommerceCart,
+  BigCommerceCheckout,
+  BigCommerceCollection,
+  BigCommercePage,
+  BigCommerceProduct,
+  BigCommerceProductOption,
+  BigCommerceProductVariant,
+  CartCustomItem,
+  DigitalOrPhysicalItem,
+  VercelCart,
+  VercelCartItem,
+  VercelCollection,
+  VercelPage,
+  VercelProduct,
+  VercelProductOption,
+  VercelProductVariant
+} from './types';
+
+type ProductsList = { productId: number; productData: BigCommerceProduct }[];
+
+const vercelFromBigCommerceLineItems = (lineItems: BigCommerceCart['lineItems']) => {
+  const { physicalItems, digitalItems, customItems } = lineItems;
+  const cartItemMapper = ({ entityId, quantity, productEntityId }: DigitalOrPhysicalItem | CartCustomItem) => ({
+    merchandiseId: productEntityId ? productEntityId.toString() : entityId.toString(),
+    quantity
+  });
+
+  return [physicalItems, digitalItems, customItems].flatMap((list) => list.map(cartItemMapper));
+};
+
+const bigCommerceToVercelOptions = (options: BigCommerceProductOption[]): VercelProductOption[] => {
+  return options.map((option) => {
+    return {
+      id: option.entityId.toString(),
+      name: option.displayName.toString(),
+      values: option.values ? option.values.edges.map(({ node: value }) => value.label) : []
+    };
+  });
+};
+const bigCommerceToVercelVariants = (
+  variants: BigCommerceProductVariant[],
+  productId: number
+): VercelProductVariant[] => {
+  return variants.map((variant) => {
+    return {
+      parentId: productId.toString(),
+      id: variant.entityId.toString(),
+      title: '',
+      availableForSale: variant.isPurchasable,
+      selectedOptions: variant.options?.edges.map(({ node: option }) => ({
+        name: option.displayName ?? '',
+        value: option.values.edges.map(({ node }) => node.label)[0] ?? ''
+      })) || [
+        {
+          name: '',
+          value: ''
+        }
+      ],
+      price: {
+        amount:
+          variant.prices?.price.value.toString() ||
+          variant.prices?.priceRange.max.value.toString() ||
+          '0',
+        currencyCode:
+          variant.prices?.price.currencyCode || variant.prices?.priceRange.max.currencyCode || ''
+      }
+    };
+  });
+};
+
+const bigCommerceToVercelProduct = (product: BigCommerceProduct): VercelProduct => {
+  const createVercelProductImage = (img: { url: string; altText: string }) => {
+    return {
+      url: img ? img.url : '',
+      altText: img ? img.altText : '',
+      width: 2048,
+      height: 2048
+    };
+  };
+  const options = product.productOptions.edges.length
+    ? bigCommerceToVercelOptions(product.productOptions.edges.map((item) => item.node))
+    : [];
+  const variants = product.variants.edges.length
+    ? bigCommerceToVercelVariants(
+        product.variants.edges.map((item) => item.node),
+        product.entityId
+      )
+    : [];
+
+  return {
+    id: product.id.toString(),
+    handle: product.path,
+    availableForSale: product.availabilityV2.status === 'Available' ? true : false,
+    title: product.name,
+    description: product.plainTextDescription || '',
+    descriptionHtml: product.description ?? '',
+    options,
+    priceRange: {
+      maxVariantPrice: {
+        amount:
+          product.prices.priceRange.max.value.toString() ||
+          product.prices.price.value.toString() ||
+          '0',
+        currencyCode:
+          product.prices.priceRange.max.currencyCode || product.prices.price.currencyCode || ''
+      },
+      minVariantPrice: {
+        amount:
+          product.prices.priceRange.min.value.toString() ||
+          product.prices.price.value.toString() ||
+          '0',
+        currencyCode:
+          product.prices.priceRange.min.currencyCode || product.prices.price.currencyCode || ''
+      }
+    },
+    variants,
+    images: product.images
+      ? product.images.edges.map(({ node: img }) => createVercelProductImage(img))
+      : [],
+    featuredImage: createVercelProductImage(product.defaultImage),
+    seo: {
+      title: product.seo.pageTitle || product.name,
+      description: product.seo.metaDescription || ''
+    },
+    tags: [product.seo.metaKeywords] || [],
+    updatedAt: product.createdAt.utc.toString()
+  };
+};
+
+const bigCommerceToVercelProducts = (products: BigCommerceProduct[]) => {
+  const reshapedProducts = [];
+
+  for (const product of products) {
+    if (product) {
+      const reshapedProduct = bigCommerceToVercelProduct(product);
+
+      if (reshapedProduct) {
+        reshapedProducts.push(reshapedProduct);
+      }
+    }
+  }
+
+  return reshapedProducts;
+};
+
+const bigCommerceToVercelCartItems = (
+  lineItems: BigCommerceCart['lineItems'],
+  products: ProductsList
+) => {
+  const getItemMapper = (products: ProductsList, isCustomItem: boolean = false) => {
+    return (item: CartCustomItem | DigitalOrPhysicalItem): VercelCartItem => {
+      const vercelProductFallback = {
+        id: '',
+        handle: '',
+        availableForSale: false,
+        title: '',
+        description: '',
+        descriptionHtml: '',
+        options: [],
+        priceRange: {
+          maxVariantPrice: { amount: '', currencyCode: '' },
+          minVariantPrice: { amount: '', currencyCode: '' }
+        },
+        variants: [],
+        featuredImage: {
+          url: '',
+          altText: '',
+          width: 0,
+          height: 0
+        },
+        images: [
+          {
+            url: '',
+            altText: '',
+            width: 0,
+            height: 0
+          }
+        ],
+        seo: { title: '', description: '' },
+        tags: [],
+        updatedAt: ''
+      };
+      let product;
+      let selectedOptions;
+
+      if (isCustomItem) {
+        product = vercelProductFallback;
+        selectedOptions = [{ name: '', value: '' }];
+      } else {
+        const productData = products.filter(
+          ({ productId }) => productId === (item as DigitalOrPhysicalItem).productEntityId
+        )[0]?.productData;
+
+        product = productData ? bigCommerceToVercelProduct(productData) : vercelProductFallback;
+        selectedOptions = (item as DigitalOrPhysicalItem).selectedOptions.map((option) => ({
+          name: option.name,
+          value: option.value || option.text || option.number?.toString() || option.fileName || ''
+        }));
+      }
+
+      return {
+        id: item.entityId.toString(), // NOTE: used as lineId || lineItemId
+        quantity: item.quantity,
+        cost: {
+          totalAmount: {
+            amount:
+            item.extendedListPrice.value.toString() || item.listPrice.value.toString() || '0',
+            currencyCode: item.extendedListPrice.currencyCode || item.listPrice.currencyCode || ''
+          }
+        },
+        merchandise: {
+          id: isCustomItem ? item.entityId.toString() : (item as DigitalOrPhysicalItem).variantEntityId!.toString(),
+          title: `${item.name}`,
+          selectedOptions,
+          product
+        }
+      };
+    };
+  };
+
+  const { physicalItems, digitalItems, customItems } = lineItems;
+  const areCustomItemsInCart = customItems.length > 0;
+  const line1 = physicalItems.map((item) => getItemMapper(products)(item));
+  const line2 = digitalItems.map((item) => getItemMapper(products)(item));
+  const line3 = areCustomItemsInCart
+    ? customItems.map((item) => getItemMapper(products, areCustomItemsInCart)(item))
+    : [];
+
+  return [...line1, ...line2, ...line3];
+};
+
+const bigCommerceToVercelCart = (
+  cart: BigCommerceCart,
+  products: ProductsList,
+  checkout: BigCommerceCheckout,
+  checkoutUrl?: string
+): VercelCart => {
+  return {
+    id: cart.entityId,
+    checkoutUrl: checkoutUrl ?? '',
+    cost: {
+      subtotalAmount: {
+        amount: checkout.subtotal.value.toString(),
+        currencyCode: checkout.subtotal.currencyCode
+      },
+      totalAmount: {
+        amount: checkout.grandTotal.value.toString(),
+        currencyCode: checkout.grandTotal.currencyCode
+      },
+      totalTaxAmount: {
+        amount: checkout.taxTotal.value.toString(),
+        currencyCode: checkout.taxTotal.currencyCode
+      }
+    },
+    lines: bigCommerceToVercelCartItems(cart.lineItems, products),
+    totalQuantity: cart.lineItems.totalQuantity
+  };
+};
+
+const bigCommerceToVercelCollection = (collection: BigCommerceCollection): VercelCollection => {
+  if (!collection) {
+    return {
+      handle: '',
+      title: '',
+      description: '',
+      seo: {
+        title: '',
+        description: ''
+      },
+      updatedAt: '',
+      path: ''
+    };
+  }
+
+  return {
+    handle: collection.entityId.toString() || collection.name,
+    title: collection.name,
+    description: collection.description,
+    seo: {
+      title: collection.seo.pageTitle,
+      description: collection.seo.metaDescription
+    },
+    updatedAt: new Date().toISOString(),
+    path: `/search${collection.path}`
+  };
+};
+
+export {
+  bigCommerceToVercelCart, bigCommerceToVercelCollection, bigCommerceToVercelProduct,
+  bigCommerceToVercelProducts, vercelFromBigCommerceLineItems
+};
+
+export const vercelToBigCommerceSorting = (
+  isReversed: boolean,
+  sortKey?: string
+): keyof typeof BigCommerceSortKeys | null => {
+  const VercelSorting: Record<string, string> = {
+    RELEVANCE: 'RELEVANCE',
+    BEST_SELLING: 'BEST_SELLING',
+    CREATED_AT: 'CREATED_AT',
+    PRICE: 'PRICE'
+  };
+
+  if (!sortKey || VercelSorting[sortKey] === undefined) {
+    return null;
+  }
+
+  if (sortKey === VercelSortKeys.PRICE) {
+    return isReversed
+      ? vercelToBigCommerceSortKeys.PRICE_ON_REVERSE
+      : vercelToBigCommerceSortKeys.PRICE;
+  }
+
+  return vercelToBigCommerceSortKeys[sortKey as keyof typeof VercelSortKeys];
+};
+
+export const bigCommerceToVercelPageContent = (page: BigCommercePage): VercelPage => {
+  return {
+    id: page.entityId.toString(),
+    title: page.name,
+    handle: page.path.slice(1),
+    body: page.htmlBody ?? '',
+    bodySummary: page.plainTextSummary ?? '',
+    seo: {
+      title: page.seo.pageTitle,
+      description: page.seo.metaDescription
+    },
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+};
\ No newline at end of file
diff --git a/lib/bigcommerce/mutations/cart.ts b/lib/bigcommerce/mutations/cart.ts
new file mode 100644
index 0000000..cc0c97c
--- /dev/null
+++ b/lib/bigcommerce/mutations/cart.ts
@@ -0,0 +1,151 @@
+import { customItemFragment, digitalItemFragment, physicalItemFragment } from '../fragments/cart';
+
+const addCartLineItemMutation = /* GraphQL */ `
+  mutation addCartLineItems($addCartLineItemsInput: AddCartLineItemsInput!) {
+    cart {
+      addCartLineItems(input: $addCartLineItemsInput) {
+        cart {
+          entityId
+          amount {
+            currencyCode
+            value
+          }
+          lineItems {
+            totalQuantity
+            physicalItems {
+              ...physicalItem
+            }
+            digitalItems {
+              ...digitalItem
+            }
+            customItems {
+              ...customItem
+            }
+          }
+        }
+      }
+    }
+  }
+  ${physicalItemFragment}
+  ${digitalItemFragment}
+  ${customItemFragment}
+`;
+
+const createCartMutation = /* GraphQL */ `
+  mutation createCart($createCartInput: CreateCartInput!) {
+    cart {
+      createCart(input: $createCartInput) {
+        cart {
+          entityId
+          amount {
+            currencyCode
+            value
+          }
+          lineItems {
+            totalQuantity
+            physicalItems {
+              ...physicalItem
+            }
+            digitalItems {
+              ...digitalItem
+            }
+            customItems {
+              ...customItem
+            }
+            giftCertificates {
+              name
+            }
+          }
+        }
+      }
+    }
+  }
+  ${physicalItemFragment}
+  ${digitalItemFragment}
+  ${customItemFragment}
+`;
+
+const deleteCartLineItemMutation = /* GraphQL */ `
+  mutation deleteCartLineItem($deleteCartLineItemInput: DeleteCartLineItemInput!) {
+    cart {
+      deleteCartLineItem(input: $deleteCartLineItemInput) {
+        deletedLineItemEntityId
+        deletedCartEntityId
+        cart {
+          entityId
+          amount {
+            currencyCode
+            value
+          }
+          lineItems {
+            physicalItems {
+              ...physicalItem
+            }
+            digitalItems {
+              ...digitalItem
+            }
+            customItems {
+              ...customItem
+            }
+            totalQuantity
+          }
+        }
+      }
+    }
+  }
+  ${physicalItemFragment}
+  ${digitalItemFragment}
+  ${customItemFragment}
+`;
+
+const updateCartLineItemMutation = /* GraphQL */ `
+  mutation updateCartLineItem($updateCartLineItemInput: UpdateCartLineItemInput!) {
+    cart {
+      updateCartLineItem(input: $updateCartLineItemInput) {
+        cart {
+          entityId
+          amount {
+            currencyCode
+            value
+          }
+          updatedAt {
+            utc
+          }
+          lineItems {
+            totalQuantity
+            physicalItems {
+              ...physicalItem
+            }
+            digitalItems {
+              ...digitalItem
+            }
+            customItems {
+              ...customItem
+            }
+          }
+        }
+      }
+    }
+  }
+  ${physicalItemFragment}
+  ${digitalItemFragment}
+  ${customItemFragment}
+`;
+
+const deleteCartMutation = /* GraphQL */ `
+  mutation deleteCart($deleteCartInput: DeleteCartInput!) {
+    cart {
+      deleteCart(input: $deleteCartInput) {
+        deletedCartEntityId
+      }
+    }
+  }
+`;
+
+export {
+  addCartLineItemMutation,
+  createCartMutation,
+  deleteCartLineItemMutation,
+  deleteCartMutation,
+  updateCartLineItemMutation
+};
diff --git a/lib/bigcommerce/queries/cart.ts b/lib/bigcommerce/queries/cart.ts
new file mode 100644
index 0000000..cc6bc4b
--- /dev/null
+++ b/lib/bigcommerce/queries/cart.ts
@@ -0,0 +1,94 @@
+import { customItemFragment, digitalItemFragment, physicalItemFragment } from '../fragments/cart';
+
+export const getCartQuery = /* GraphQL */ `
+  query getCart($entityId: String!) {
+    site {
+      cart(entityId: $entityId) {
+        entityId
+        currencyCode
+        isTaxIncluded
+        amount {
+          currencyCode
+          value
+        }
+        lineItems {
+          physicalItems {
+            ...physicalItem
+          }
+          digitalItems {
+            ...digitalItem
+          }
+          customItems {
+            ...customItem
+          }
+          giftCertificates {
+            entityId
+            name
+            theme
+            amount {
+              currencyCode
+              value
+            }
+            isTaxable
+            sender {
+              name
+              email
+            }
+            recipient {
+              name
+              email
+            }
+            message
+          }
+          customItems {
+            entityId
+            sku
+            name
+            quantity
+            listPrice {
+              currencyCode
+              value
+            }
+            extendedListPrice {
+              currencyCode
+              value
+            }
+          }
+          totalQuantity
+        }
+        createdAt {
+          utc
+        }
+        updatedAt {
+          utc
+        }
+        locale
+      }
+    }
+  }
+  ${physicalItemFragment}
+  ${digitalItemFragment}
+  ${customItemFragment}
+`;
+
+export const getCheckoutNodeQuery = /* GraphQL */ `
+  query getCheckoutNode($nodeId: ID!) {
+    node(id: $nodeId) {
+      ... on Checkout {
+        entityId
+        subtotal {
+          currencyCode
+          value
+        }
+        taxTotal {
+          currencyCode
+          value
+        }
+        grandTotal {
+          currencyCode
+          value
+        }
+      }
+    }
+  }
+`;
diff --git a/lib/bigcommerce/queries/category.ts b/lib/bigcommerce/queries/category.ts
new file mode 100644
index 0000000..df22c4d
--- /dev/null
+++ b/lib/bigcommerce/queries/category.ts
@@ -0,0 +1,28 @@
+export const getCategoryQuery = /* GraphQL */ `
+  query getCategory($entityId: Int!) {
+    site {
+      category(entityId: $entityId) {
+        entityId
+        name
+        path
+        description
+        seo {
+          metaDescription
+          metaKeywords
+          pageTitle
+        }
+      }
+    }
+  }
+`;
+
+export const getStoreCategoriesQuery = /* GraphQL */ `
+  query getStoreCategories {
+    site {
+      categoryTree {
+        entityId
+        name
+      }
+    }
+  }
+`;
diff --git a/lib/bigcommerce/queries/checkout.ts b/lib/bigcommerce/queries/checkout.ts
new file mode 100644
index 0000000..2d32f3c
--- /dev/null
+++ b/lib/bigcommerce/queries/checkout.ts
@@ -0,0 +1,20 @@
+export const getCheckoutQuery = /* GraphQL */ `
+  query getCheckout($entityId: String) {
+    site {
+      checkout(entityId: $entityId) {
+        subtotal {
+          currencyCode
+          value
+        }
+        taxTotal {
+          currencyCode
+          value
+        }
+        grandTotal {
+          currencyCode
+          value
+        }
+      }
+    }
+  }
+`;
diff --git a/lib/bigcommerce/queries/menu.ts b/lib/bigcommerce/queries/menu.ts
new file mode 100644
index 0000000..d4aadd6
--- /dev/null
+++ b/lib/bigcommerce/queries/menu.ts
@@ -0,0 +1,21 @@
+export const getMenuQuery = /* GraphQL */ `
+  query getMenu {
+    site {
+      categoryTree {
+        ...CategoryFields
+        children {
+          ...CategoryFields
+          children {
+            ...CategoryFields
+          }
+        }
+      }
+    }
+  }
+  fragment CategoryFields on CategoryTreeItem {
+    hasChildren
+    entityId
+    name
+    path
+  }
+`;
diff --git a/lib/bigcommerce/queries/page.ts b/lib/bigcommerce/queries/page.ts
new file mode 100644
index 0000000..10556a9
--- /dev/null
+++ b/lib/bigcommerce/queries/page.ts
@@ -0,0 +1,89 @@
+import { pageContentFragment } from '../fragments/page';
+
+export const getPageQuery = /* GraphQL */ `
+  query getPage($entityId: Int!) {
+    site {
+      content {
+        page(entityId: $entityId) {
+          ...pageContent
+          ... on NormalPage {
+            plainTextSummary(characterLimit: 100)
+            htmlBody
+            path
+          }
+          ... on ContactPage {
+            plainTextSummary(characterLimit: 100)
+            htmlBody
+            path
+          }
+          ... on BlogIndexPage {
+            path
+          }
+          ... on RawHtmlPage {
+            plainTextSummary(characterLimit: 100)
+            htmlBody
+            path
+          }
+        }
+        # TODO: use it later on
+        # blog {
+        #   name
+        #   path
+        #   description
+        #   isVisibleInNavigation
+        #   posts {
+        #     edges {
+        #       node {
+        #         name
+        #         path
+        #         plainTextSummary
+        #         publishedDate {
+        #           utc
+        #         }
+        #         author
+        #         htmlBody
+        #         entityId
+        #       }
+        #     }
+        #   }
+        # }
+      }
+    }
+  }
+  ${pageContentFragment}
+`;
+
+export const getPagesQuery = /* GraphQL */ `
+  query getPages {
+    site {
+      content {
+        pages {
+          edges {
+            node {
+              ...pageContent
+              ... on NormalPage {
+                plainTextSummary(characterLimit: 100)
+                htmlBody
+                path
+              }
+              ... on ContactPage {
+                plainTextSummary(characterLimit: 100)
+                htmlBody
+                path
+              }
+              ... on BlogIndexPage {
+                path
+              }
+              ... on RawHtmlPage {
+                plainTextSummary(characterLimit: 100)
+                htmlBody
+                path
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  ${pageContentFragment}
+`;
diff --git a/lib/bigcommerce/queries/product.ts b/lib/bigcommerce/queries/product.ts
new file mode 100644
index 0000000..cca2fb7
--- /dev/null
+++ b/lib/bigcommerce/queries/product.ts
@@ -0,0 +1,130 @@
+import { productFragment } from '../fragments/product';
+
+export const getProductQuery = /* GraphQL */ `
+  query productById($productId: Int!) {
+    site {
+      product(entityId: $productId) {
+        ...product
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const getStoreProductsQuery = /* GraphQL */ `
+  query getStoreProducts($entityIds: [Int!]) {
+    site {
+      products(entityIds: $entityIds) {
+        edges {
+          node {
+            ...product
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const getProductsCollectionQuery = /* GraphQL */ `
+  query getProductsCollection(
+    $entityId: Int!
+    $sortBy: CategoryProductSort
+    $hideOutOfStock: Boolean
+    $first: Int
+  ) {
+    site {
+      category(entityId: $entityId) {
+        products(sortBy: $sortBy, hideOutOfStock: $hideOutOfStock, first: $first) {
+          edges {
+            node {
+              ...product
+            }
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const searchProductsQuery = /* GraphQL */ `
+  query searchProducts($filters: SearchProductsFiltersInput!, $sort: SearchProductsSortInput) {
+    site {
+      search {
+        searchProducts(filters: $filters, sort: $sort) {
+          products {
+            edges {
+              node {
+                ...product
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const getProductsRecommedationsQuery = /* GraphQL */ `
+  query getProductsRecommedations($productId: ID) {
+    site {
+      product(id: $productId) {
+        relatedProducts {
+          edges {
+            node {
+              ...product
+            }
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const getNewestProductsQuery = /* GraphQL */ `
+  query getNewestProducts($first: Int) {
+    site {
+      newestProducts(first: $first) {
+        edges {
+          node {
+            ...product
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const getFeaturedProductsQuery = /* GraphQL */ `
+  query getFeaturedProducts($first: Int) {
+    site {
+      featuredProducts(first: $first) {
+        edges {
+          node {
+            ...product
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
+
+export const getPopularProductsQuery = /* GraphQL */ `
+  query bestSellingProducts($first: Int) {
+    site {
+      bestSellingProducts(first: $first) {
+        edges {
+          node {
+            ...product
+          }
+        }
+      }
+    }
+  }
+  ${productFragment}
+`;
diff --git a/lib/bigcommerce/queries/route.ts b/lib/bigcommerce/queries/route.ts
new file mode 100644
index 0000000..d0747ae
--- /dev/null
+++ b/lib/bigcommerce/queries/route.ts
@@ -0,0 +1,35 @@
+export const getEntityIdByRouteQuery = /* GraphQL */ `
+  query getEntityIdByRoute($path: String!) {
+    site {
+      route(path: $path) {
+        node {
+          __typename
+          ... on Product {
+            entityId
+          }
+          ... on Category {
+            entityId
+          }
+          ... on Brand {
+            entityId
+          }
+          #  NOTE: this API is still not public
+          ... on NormalPage {
+            entityId
+          }
+          ... on ContactPage {
+            entityId
+          }
+          ... on RawHtmlPage {
+            entityId
+          }
+          # TODO: use it later on
+          # ... on Blog {
+          #   name
+          #   id
+          # }
+        }
+      }
+    }
+  }
+`;
diff --git a/lib/bigcommerce/storefront-config.ts b/lib/bigcommerce/storefront-config.ts
new file mode 100644
index 0000000..4255798
--- /dev/null
+++ b/lib/bigcommerce/storefront-config.ts
@@ -0,0 +1,45 @@
+import { BIGCOMMERCE_API_URL } from './constants';
+
+interface StorefrontCheckoutResponse {
+  data?: {
+    cart_url: string;
+    checkout_url: string;
+    embedded_checkout_url: string;
+  };
+  status: number;
+}
+
+type CheckoutCache = {
+  activeCartId: string | null;
+  data: StorefrontCheckoutResponse | null;
+}
+
+const createCartRedirectUrl = () => {
+  const localCache: CheckoutCache= {
+    activeCartId: null,
+    data: null,
+  }
+
+  return async (cartId: string): Promise<StorefrontCheckoutResponse> => {
+    if (localCache.activeCartId !== cartId || !localCache.data) {
+      const response = await fetch(`${BIGCOMMERCE_API_URL}/stores/${process.env.BIGCOMMERCE_STORE_HASH}/v3/carts/${cartId}/redirect_urls`, {
+        method: 'POST',
+        headers: {
+          accept: 'application/json',
+          'content-type': 'application/json',
+          'x-auth-token': process.env.BIGCOMMERCE_ACCESS_TOKEN!,
+        },
+      });
+      const data = (await response.json()) as StorefrontCheckoutResponse;
+
+      localCache.activeCartId = cartId;
+      localCache.data = data;
+
+      return data;
+    }
+
+    return localCache.data;
+  };
+}
+
+export const memoizedCartRedirectUrl = createCartRedirectUrl();
\ No newline at end of file
diff --git a/lib/bigcommerce/type-guards.ts b/lib/bigcommerce/type-guards.ts
new file mode 100644
index 0000000..fef46b2
--- /dev/null
+++ b/lib/bigcommerce/type-guards.ts
@@ -0,0 +1,27 @@
+export interface VercelCommerceErrorLike {
+  status: number;
+  message: Error;
+  cause?: Error;
+}
+
+export const isObject = (object: unknown): object is Record<string, unknown> => {
+  return typeof object === 'object' && object !== null && !Array.isArray(object);
+};
+
+export const isVercelCommerceError = (error: unknown): error is VercelCommerceErrorLike => {
+  if (!isObject(error)) return false;
+
+  if (error instanceof Error) return true;
+
+  return findError(error);
+};
+
+function findError<T extends object>(error: T): boolean {
+  if (Object.prototype.toString.call(error) === '[object Error]') {
+    return true;
+  }
+
+  const prototype = Object.getPrototypeOf(error) as T | null;
+
+  return prototype === null ? false : findError(prototype);
+}
\ No newline at end of file
diff --git a/lib/bigcommerce/types.ts b/lib/bigcommerce/types.ts
new file mode 100644
index 0000000..64722b5
--- /dev/null
+++ b/lib/bigcommerce/types.ts
@@ -0,0 +1,606 @@
+export type Maybe<T> = T | null;
+
+export type Connection<T> = {
+  edges: Array<Edge<T>>;
+};
+
+export type Edge<T> = {
+  node: T;
+};
+
+export type VercelPage = {
+  id: string;
+  title: string;
+  handle: string;
+  body: string;
+  bodySummary: string;
+  seo?: VercelSEO;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type VercelMenu = {
+  title: string;
+  path: string;
+};
+
+export type VercelCollection = {
+  handle: string;
+  title: string;
+  description: string;
+  seo: VercelSEO;
+  updatedAt: string;
+  path: string;
+};
+
+type VercelMoney = {
+  amount: string;
+  currencyCode: string;
+};
+
+export type Image = {
+  url: string;
+  altText: string;
+  width: number;
+  height: number;
+};
+
+export type VercelProduct = {
+  id: string;
+  handle: string;
+  availableForSale: boolean;
+  title: string;
+  description: string;
+  descriptionHtml: string;
+  options: VercelProductOption[];
+  priceRange: {
+    maxVariantPrice: VercelMoney;
+    minVariantPrice: VercelMoney;
+  };
+  variants: VercelProductVariant[];
+  featuredImage: Image;
+  images: Image[];
+  seo: VercelSEO;
+  tags: string[];
+  updatedAt: string;
+};
+
+export type VercelProductOption = {
+  id: string;
+  name: string;
+  values: string[];
+};
+
+export type VercelProductVariant = {
+  parentId?: string;
+  id: string;
+  title: string;
+  availableForSale: boolean;
+  selectedOptions: {
+    name: string;
+    value: string;
+  }[];
+  price: VercelMoney;
+};
+
+export type VercelSEO = {
+  title: string;
+  description: string;
+};
+
+export type VercelCartItem = {
+  id: string;
+  quantity: number;
+  cost: {
+    totalAmount: VercelMoney;
+  };
+  merchandise: {
+    id: string;
+    title: string;
+    selectedOptions: {
+      name: string;
+      value: string;
+    }[];
+    product: VercelProduct;
+  };
+};
+
+export type VercelCart = {
+  id: string;
+  checkoutUrl: string;
+  cost: {
+    subtotalAmount: VercelMoney;
+    totalAmount: VercelMoney;
+    totalTaxAmount: VercelMoney;
+  };
+  lines: VercelCartItem[];
+  totalQuantity: number;
+};
+
+export type BigCommerceCartOperation = {
+  data: {
+    site: {
+      cart: BigCommerceCart;
+    };
+  };
+  variables: {
+    entityId: string;
+  };
+};
+
+export type BigCommerceCreateCartOperation = {
+  data: {
+    cart: {
+      createCart: {
+        cart: BigCommerceCart;
+      };
+    };
+  };
+  variables: {
+    createCartInput: {
+      lineItems: CartItem[];
+    };
+  };
+};
+
+export type BigCommerceAddToCartOperation = {
+  data: {
+    cart: {
+      addCartLineItems: {
+        cart: BigCommerceCart;
+      };
+    };
+  };
+  variables: {
+    addCartLineItemsInput: {
+      cartEntityId: string;
+      data: {
+        lineItems: CartItem[];
+      };
+    };
+  };
+};
+
+export type BigCommerceDeleteCartItemOperation = {
+  data: {
+    cart: {
+      deleteCartLineItem: {
+        cart: BigCommerceCart;
+      };
+    };
+  };
+  variables: {
+    deleteCartLineItemInput: {
+      cartEntityId: string;
+      lineItemEntityId: string;
+    };
+  };
+};
+
+export type BigCommerceUpdateCartItemOperation = {
+  data: {
+    cart: {
+      updateCartLineItem: {
+        cart: BigCommerceCart;
+      };
+    };
+  };
+  variables: {
+    updateCartLineItemInput: {
+      cartEntityId: string;
+      lineItemEntityId: string;
+      data: {
+        lineItem: CartItem;
+      };
+    };
+  };
+};
+
+export type BigCommerceCheckoutOperation = {
+  data: {
+    site: {
+      checkout: BigCommerceCheckout;
+    };
+  };
+  variables: {
+    entityId: string;
+  };
+};
+
+export type BigCommerceProductOperation = {
+  data: {
+    site: {
+      product: BigCommerceProduct;
+    };
+  };
+  variables: {
+    productId: number;
+  };
+};
+
+export type BigCommerceProductsOperation = {
+  data: {
+    site: {
+      products: Connection<BigCommerceProduct>;
+    };
+  };
+  variables: {
+    entityIds: number[] | [];
+  };
+};
+
+export type BigCommerceEntityIdOperation = {
+  data: {
+    site: {
+      route: {
+        node: {
+          __typename:
+            | 'Product'
+            | 'Category'
+            | 'Brand'
+            | 'NormalPage'
+            | 'ContactPage'
+            | 'RawHtmlPage'
+            | 'BlogIndexPage';
+          entityId: number;
+        };
+      };
+    };
+  };
+  variables: {
+    path: string;
+  };
+};
+
+export type BigCommerceRecommendationsOperation = {
+  data: {
+    site: {
+      product: {
+        relatedProducts: Connection<BigCommerceProduct>;
+      };
+    };
+  };
+  variables: {
+    productId: number | string;
+  };
+};
+
+export type BigCommerceSearchProductsOperation = {
+  data: {
+    site: {
+      search: {
+        searchProducts: {
+          products: Connection<BigCommerceProduct>;
+        };
+      };
+    };
+  };
+  variables: {
+    filters: {
+      searchTerm: string;
+    };
+    sort: string | null;
+  };
+};
+
+export type BigCommerceMenuOperation = {
+  data: {
+    site: {
+      categoryTree: BigCommerceCategoryTreeItem[];
+    };
+  };
+};
+
+export type BigCommerceCollectionOperation = {
+  data: {
+    site: {
+      category: BigCommerceCollection;
+    };
+  };
+  variables: {
+    entityId: number;
+  };
+};
+
+export type BigCommerceProductsCollectionOperation = {
+  data: {
+    site: {
+      category: {
+        products: Connection<BigCommerceProduct>;
+      };
+    };
+  };
+  variables: {
+    entityId: number;
+    sortBy: string | null;
+    hideOutOfStock: boolean;
+    first: number;
+  };
+};
+
+export type BigCommerceNewestProductsOperation = {
+  data: {
+    site: {
+      newestProducts: Connection<BigCommerceProduct>;
+    };
+  };
+  variables: {
+    first: number;
+  };
+};
+
+export type BigCommerceFeaturedProductsOperation = {
+  data: {
+    site: {
+      featuredProducts: Connection<BigCommerceProduct>;
+    };
+  };
+  variables: {
+    first: number;
+  };
+};
+
+export type BigCommercePopularProductsOperation = {
+  data: {
+    site: {
+      bestSellingProducts: Connection<BigCommerceProduct>;
+    };
+  };
+  variables: {
+    first: number;
+  };
+};
+
+export type BigCommerceCollectionsOperation = {
+  data: {
+    site: {
+      categoryTree: BigCommerceCategoryWithId[];
+    };
+  };
+};
+
+export type BigCommercePageOperation = {
+  data: {
+    site: {
+      content: {
+        page: BigCommercePage;
+      };
+    };
+  };
+  variables: { entityId: number };
+};
+
+export type BigCommercePagesOperation = {
+  data: {
+    site: {
+      content: {
+        pages: Connection<BigCommercePage>;
+      };
+    };
+  };
+};
+
+export type BigCommerceCheckout = {
+  subtotal: BigCommerceMoney;
+  grandTotal: BigCommerceMoney;
+  taxTotal: BigCommerceMoney;
+};
+
+export type BigCommerceCategoryWithId = Omit<BigCommerceCollection, 'description' | 'seo' | 'path'>;
+
+export type BigCommerceSEO = {
+  pageTitle: string;
+  metaDescription: string;
+  metaKeywords: string;
+};
+
+export type BigCommerceCollection = {
+  entityId: number;
+  name: string;
+  path: string;
+  description: string;
+  seo: BigCommerceSEO;
+};
+
+export type BigCommerceCart = {
+  entityId: string;
+  currencyCode: string;
+  isTaxIncluded: boolean;
+  baseAmount: BigCommerceMoney;
+  discountedAmount: BigCommerceMoney;
+  amount: BigCommerceMoney;
+  discounts: CartDiscount[];
+  lineItems: CartLineItems;
+  createdAt: { utc: Date };
+  updatedAt: { utc: Date };
+  locale: string;
+};
+
+type CartLineItems = {
+  physicalItems: DigitalOrPhysicalItem[];
+  digitalItems: DigitalOrPhysicalItem[];
+  customItems: CartCustomItem[];
+  giftCertificates: CartGiftCertificate[];
+  totalQuantity: number;
+};
+
+type CartItem = {
+  quantity: number;
+  productEntityId: number;
+  variantEntityId?: number;
+};
+
+export type BigCommerceCategoryTreeItem = {
+  name: string;
+  path: string;
+  hasChildren: boolean;
+  entityId: number;
+  children?: BigCommerceCategoryTreeItem[];
+};
+
+export type BigCommercePage = {
+  __typename: 'NormalPage' | 'ContactPage' | 'RawHtmlPage' | 'BlogIndexPage';
+  entityId: number;
+  name: string;
+  isVisibleInNavigation: boolean;
+  seo: BigCommerceSEO;
+  path: string;
+  plainTextSummary?: string;
+  htmlBody?: string;
+};
+
+export type BigCommerceMoney = {
+  value: number;
+  currencyCode: string;
+};
+
+type CartDiscount = {
+  entityId: string;
+  discountedAmount: BigCommerceMoney;
+};
+
+type CartGiftCertificatePersonDetails = {
+  name: string;
+  email: string;
+};
+
+export type DigitalOrPhysicalItem = {
+  entityId: number;
+  parentEntityId: number | null;
+  productEntityId: number;
+  variantEntityId: number | null;
+  sku: string;
+  name: string;
+  url: string;
+  imageUrl: string | null;
+  brand: string | null;
+  quantity: number;
+  isTaxable: boolean;
+  listPrice: BigCommerceMoney;
+  extendedListPrice: BigCommerceMoney;
+  selectedOptions: {
+    entityId: number;
+    name: string;
+    value?: string;
+    date?: { utc: Date };
+    text?: string;
+    number?: string;
+    fileName?: ScrollSetting;
+  }[];
+  isShippingRequired: boolean;
+};
+
+export type CartCustomItem = {
+  entityId: string;
+  productEntityId: undefined;
+  sku: string;
+  name: string;
+  quantity: number;
+  listPrice: BigCommerceMoney;
+  extendedListPrice: BigCommerceMoney;
+};
+
+type CartGiftCertificate = {
+  entityId: number;
+  productEntityId: undefined;
+  name: string;
+  amount: BigCommerceMoney;
+  isTaxable: boolean;
+  message: string;
+  sender: CartGiftCertificatePersonDetails;
+  recipient: CartGiftCertificatePersonDetails;
+};
+
+export type BigCommerceProductVariant = {
+  id: number;
+  entityId: number;
+  sku: string;
+  upc: string | null;
+  isPurchasable: boolean;
+  prices: {
+    price: BigCommerceMoney;
+    priceRange: {
+      min: BigCommerceMoney;
+      max: BigCommerceMoney;
+    };
+  };
+  options: {
+    edges: Array<{
+      node: {
+        entityId: number;
+        displayName: string;
+        values: {
+          edges: Array<{
+            node: {
+              entityId: number;
+              label: string;
+            };
+          }>;
+        };
+      };
+    }>;
+  };
+};
+
+export type BigCommerceProductOption = {
+  __typename: string;
+  entityId: number;
+  displayName: string;
+  isRequired: boolean;
+  displayStyle: string;
+  values: {
+    edges: Array<{
+      node: {
+        entityId: number;
+        label: string;
+        isDefault: boolean;
+        hexColors: string[];
+        imageUrl: string | null;
+        isSelected: boolean;
+      };
+    }>;
+  };
+};
+
+export type BigCommerceProduct = {
+  id: number;
+  entityId: number;
+  sku: string;
+  upc: string | null;
+  name: string;
+  brand: {
+    name: string;
+  } | null;
+  plainTextDescription: string;
+  description: string;
+  availabilityV2: {
+    status: string;
+    description: string;
+  };
+  defaultImage: {
+    url: string;
+    altText: string;
+  };
+  images: {
+    edges: Array<{
+      node: {
+        url: string;
+        altText: string;
+      };
+    }>;
+  };
+  seo: BigCommerceSEO;
+  path: string;
+  prices: {
+    price: BigCommerceMoney;
+    priceRange: {
+      min: BigCommerceMoney;
+      max: BigCommerceMoney;
+    };
+  };
+  createdAt: {
+    utc: Date;
+  };
+  variants: Connection<BigCommerceProductVariant>;
+  productOptions: Connection<BigCommerceProductOption>;
+};
\ No newline at end of file
diff --git a/lib/bigcommerce/utils.ts b/lib/bigcommerce/utils.ts
new file mode 100644
index 0000000..9e8699e
--- /dev/null
+++ b/lib/bigcommerce/utils.ts
@@ -0,0 +1,43 @@
+import { ReadonlyURLSearchParams } from 'next/navigation';
+
+export const createUrl = (pathname: string, params: URLSearchParams | ReadonlyURLSearchParams) => {
+  const paramsString = params.toString();
+  const queryString = `${paramsString.length ? '?' : ''}${paramsString}`;
+
+  return `${pathname}${queryString}`;
+};
+
+export const ensureStartsWith = (stringToCheck: string, startsWith: string) =>
+  stringToCheck.startsWith(startsWith) ? stringToCheck : `${startsWith}${stringToCheck}`;
+
+export const validateEnvironmentVariables = () => {
+  const requiredEnvironmentVariables = [
+    'BIGCOMMERCE_CANONICAL_STORE_DOMAIN',
+    'BIGCOMMERCE_ACCESS_TOKEN',
+    'BIGCOMMERCE_CUSTOMER_IMPERSONATION_TOKEN'
+  ];
+  const missingEnvironmentVariables = [] as string[];
+
+  requiredEnvironmentVariables.forEach((envVar) => {
+    if (!process.env[envVar]) {
+      missingEnvironmentVariables.push(envVar);
+    }
+  });
+
+  if (missingEnvironmentVariables.length) {
+    throw new Error(
+      `The following environment variables are missing. Your site will not work without them. Read more: https://vercel.com/docs/integrations/shopify#configure-environment-variables\n\n${missingEnvironmentVariables.join(
+        '\n'
+      )}\n`
+    );
+  }
+
+  if (
+    process.env.SHOPIFY_STORE_DOMAIN?.includes('[') ||
+    process.env.SHOPIFY_STORE_DOMAIN?.includes(']')
+  ) {
+    throw new Error(
+      'Your `SHOPIFY_STORE_DOMAIN` environment variable includes brackets (ie. `[` and / or `]`). Your site will not work with them there. Please remove them.'
+    );
+  }
+};
diff --git a/lib/medusa/constants.ts b/lib/medusa/constants.ts
new file mode 100644
index 0000000..07ba73d
--- /dev/null
+++ b/lib/medusa/constants.ts
@@ -0,0 +1,39 @@
+
+export type SortFilterItem = {
+  title: string;
+  slug: string | null;
+  sortKey: 'RELEVANCE' | 'BEST_SELLING' | 'CREATED_AT' | 'PRICE';
+  reverse: boolean;
+};
+
+export const defaultSort: SortFilterItem = {
+  title: 'Relevance',
+  slug: null,
+  sortKey: 'RELEVANCE',
+  reverse: false
+};
+
+export const sorting: SortFilterItem[] = [
+  defaultSort,
+  { title: 'Trending', slug: 'trending-desc', sortKey: 'BEST_SELLING', reverse: false }, // asc
+  { title: 'Latest arrivals', slug: 'latest-desc', sortKey: 'CREATED_AT', reverse: true },
+  { title: 'Price: Low to high', slug: 'price-asc', sortKey: 'PRICE', reverse: false }, // asc
+  { title: 'Price: High to low', slug: 'price-desc', sortKey: 'PRICE', reverse: true }
+];
+
+export const TAGS = {
+  categories: 'categories',
+  products: 'products'
+};
+
+export const HIDDEN_PRODUCT_TAG = 'nextjs-frontend-hidden';
+export const DEFAULT_OPTION = 'Default Title';
+
+export const CHECKOUT_PAGE_PROPS = {
+  title: 'Checkout',
+  body: `Checkout is not implemented yet in this template. Check out 
+        <a href="https://docs.medusajs.com/modules/carts-and-checkout/storefront/implement-checkout-flow">our guide on implementing a checkout flow</a> to learn more.`,
+  description: 'Checkout is not implemented yet in this template',
+  updatedAt: new Date().toISOString(),
+  createdAt: new Date().toISOString()
+};
diff --git a/lib/medusa/helpers.ts b/lib/medusa/helpers.ts
new file mode 100644
index 0000000..6e6f64e
--- /dev/null
+++ b/lib/medusa/helpers.ts
@@ -0,0 +1,46 @@
+import { isEmpty } from './utils';
+import { MedusaProductVariant, Money, RegionInfo } from './types';
+
+type ComputeAmountParams = {
+  amount: number;
+  region: RegionInfo;
+  includeTaxes?: boolean;
+};
+
+/**
+ * Takes an amount, a region, and returns the amount as a decimal including or excluding taxes
+ */
+export const computeAmount = ({ amount, region, includeTaxes = true }: ComputeAmountParams) => {
+  const toDecimal = convertToDecimal(amount, region.currency_code);
+
+  const taxRate = includeTaxes ? getTaxRate(region) : 0;
+
+  const amountWithTaxes = toDecimal * (1 + taxRate);
+
+  return amountWithTaxes;
+};
+
+/**
+ * Takes a product variant, and returns the amount as a decimal including or excluding taxes and the currency code
+ */
+export const calculateVariantAmount = (variant: MedusaProductVariant): Money => {
+  const currencyCode = variant.prices?.[0]?.currency_code ?? 'USD';
+  const amount = convertToDecimal(variant.prices?.[0]?.amount || 0, currencyCode).toString();
+  return {
+    amount,
+    currencyCode
+  };
+};
+
+// we should probably add a more extensive list
+const noDivisionCurrencies = ['krw', 'jpy', 'vnd'];
+
+export const convertToDecimal = (amount: number, currencyCode = 'USD') => {
+  const divisor = noDivisionCurrencies.includes(currencyCode.toLowerCase()) ? 1 : 100;
+
+  return Math.floor(amount) / divisor;
+};
+
+const getTaxRate = (region?: RegionInfo) => {
+  return region && !isEmpty(region) ? region?.tax_rate / 100 : 0;
+};
\ No newline at end of file
diff --git a/lib/medusa/index.ts b/lib/medusa/index.ts
new file mode 100644
index 0000000..8a87fc0
--- /dev/null
+++ b/lib/medusa/index.ts
@@ -0,0 +1,520 @@
+import { isMedusaError } from './type-guards';
+
+import { revalidateTag } from 'next/cache';
+import { headers } from 'next/headers';
+import { NextRequest, NextResponse } from 'next/server';
+import { TAGS } from './constants';
+import { calculateVariantAmount, computeAmount, convertToDecimal } from './helpers';
+import {
+  Cart,
+  CartItem,
+  Image,
+  MedusaCart,
+  MedusaImage,
+  MedusaLineItem,
+  MedusaProduct,
+  MedusaProductCollection,
+  MedusaProductOption,
+  MedusaProductVariant,
+  Product,
+  ProductCategory,
+  ProductCollection,
+  ProductOption,
+  ProductVariant,
+  SelectedOption
+} from './types';
+import { mapOptionIds } from './utils';
+
+const ENDPOINT = process.env.NEXT_PUBLIC_MEDUSA_BACKEND_API ?? 'http://localhost:9000';
+const MEDUSA_API_KEY = process.env.MEDUSA_API_KEY ?? '';
+
+export default async function medusaRequest({
+  cache = 'force-cache',
+  method,
+  path,
+  payload,
+  tags
+}: {
+  cache?: RequestCache;
+  method: string;
+  path: string;
+  payload?: Record<string, unknown> | undefined;
+  tags?: string[];
+}) {
+  const options: RequestInit = {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+      'x-publishable-key': MEDUSA_API_KEY
+    },
+    cache,
+    ...(tags && { next: { tags } })
+  };
+
+  if (path.includes('/carts')) {
+    options.cache = 'no-cache';
+  }
+
+  if (payload) {
+    options.body = JSON.stringify(payload);
+  }
+
+  try {
+    const result = await fetch(`${ENDPOINT}/store${path}`, options);
+
+    const body = await result.json();
+
+    if (body.errors) {
+      throw body.errors[0];
+    }
+
+    return {
+      status: result.status,
+      body
+    };
+  } catch (e) {
+    if (isMedusaError(e)) {
+      throw {
+        status: e.status || 500,
+        message: e.message
+      };
+    }
+
+    throw {
+      error: e
+    };
+  }
+}
+
+const reshapeCart = (cart: MedusaCart): Cart => {
+  const lines = cart?.items?.map((item) => reshapeLineItem(item)) || [];
+  const totalQuantity = lines.reduce((a, b) => a + b.quantity, 0);
+  const checkoutUrl = '/checkout'; // todo: implement medusa checkout flow
+  const currencyCode = cart.region?.currency_code.toUpperCase() || 'USD';
+
+  let subtotalAmount = '0';
+  if (cart.subtotal && cart.region) {
+    subtotalAmount = computeAmount({ amount: cart.subtotal, region: cart.region }).toString();
+  }
+
+  let totalAmount = '0';
+  if (cart.total && cart.region) {
+    totalAmount = computeAmount({ amount: cart.total, region: cart.region }).toString();
+  }
+
+  let totalTaxAmount = '0';
+  if (cart.tax_total && cart.region) {
+    totalTaxAmount = computeAmount({ amount: cart.tax_total, region: cart.region }).toString();
+  }
+
+  const cost = {
+    subtotalAmount: {
+      amount: subtotalAmount,
+      currencyCode: currencyCode
+    },
+    totalAmount: {
+      amount: totalAmount,
+      currencyCode: currencyCode
+    },
+    totalTaxAmount: {
+      amount: totalTaxAmount,
+      currencyCode: currencyCode
+    }
+  };
+
+  return {
+    ...cart,
+    totalQuantity,
+    checkoutUrl,
+    lines,
+    cost
+  };
+};
+
+const reshapeLineItem = (lineItem: MedusaLineItem): CartItem => {
+  const product = {
+    title: lineItem.title,
+    priceRange: {
+      maxVariantPrice: calculateVariantAmount(lineItem.variant)
+    },
+    updatedAt: lineItem.updated_at,
+    createdAt: lineItem.created_at,
+    tags: [],
+    descriptionHtml: lineItem.description ?? '',
+    featuredImage: {
+      url: lineItem.thumbnail ?? '',
+      altText: lineItem.title ?? ''
+    },
+    availableForSale: true,
+    variants: [lineItem.variant && reshapeProductVariant(lineItem.variant)],
+    handle: lineItem.variant?.product?.handle ?? '',
+    options: [] as ProductOption[]
+  };
+
+  const selectedOptions =
+    lineItem.variant?.options?.map((option) => ({
+      name: option.option?.title ?? '',
+      value: option.value
+    })) || [];
+
+  const merchandise = {
+    id: lineItem.variant_id || lineItem.id,
+    selectedOptions,
+    product,
+    title: lineItem.description ?? ''
+  };
+
+  const cost = {
+    totalAmount: {
+      amount: convertToDecimal(
+        lineItem.total,
+        lineItem.variant?.prices?.[0]?.currency_code
+      ).toString(),
+      currencyCode: lineItem.variant?.prices?.[0]?.currency_code.toUpperCase() || 'EUR'
+    }
+  };
+  const quantity = lineItem.quantity;
+
+  return {
+    ...lineItem,
+    merchandise,
+    cost,
+    quantity
+  };
+};
+
+const reshapeImages = (images?: MedusaImage[], productTitle?: string): Image[] => {
+  if (!images) return [];
+  return images.map((image) => {
+    const filename = image.url.match(/.*\/(.*)\..*/)![1];
+    return {
+      ...image,
+      altText: `${productTitle} - ${filename}`
+    };
+  });
+};
+
+const reshapeProduct = (product: MedusaProduct): Product => {
+  const variant = product.variants?.[0];
+
+  let amount = '0';
+  let currencyCode = 'USD';
+  if (variant && variant.prices?.[0]?.amount) {
+    currencyCode = variant.prices?.[0]?.currency_code.toUpperCase() ?? 'USD';
+    amount = convertToDecimal(variant.prices[0].amount, currencyCode).toString();
+  }
+
+  const priceRange = {
+    maxVariantPrice: {
+      amount,
+      currencyCode: product.variants?.[0]?.prices?.[0]?.currency_code.toUpperCase() ?? ''
+    }
+  };
+
+  const updatedAt = product.updated_at;
+  const createdAt = product.created_at;
+  const tags = product.tags?.map((tag) => tag.value) || [];
+  const descriptionHtml = product.description ?? '';
+  const featuredImageFilename = product.thumbnail?.match(/.*\/(.*)\..*/)![1];
+  const featuredImage = {
+    url: product.thumbnail ?? '',
+    altText: product.thumbnail ? `${product.title} - ${featuredImageFilename}` : ''
+  };
+  const availableForSale = product.variants?.[0]?.purchasable || true;
+  const images = reshapeImages(product.images, product.title);
+
+  const variants = product.variants.map((variant) =>
+    reshapeProductVariant(variant, product.options)
+  );
+
+  let options = [] as ProductOption[];
+  product.options && (options = product.options.map((option) => reshapeProductOption(option)));
+
+  return {
+    ...product,
+    images,
+    featuredImage,
+    priceRange,
+    updatedAt,
+    createdAt,
+    tags,
+    descriptionHtml,
+    availableForSale,
+    options,
+    variants
+  };
+};
+
+const reshapeProductOption = (productOption: MedusaProductOption): ProductOption => {
+  const availableForSale = productOption.product?.variants?.[0]?.purchasable || true;
+  const name = productOption.title;
+  let values = productOption.values?.map((option) => option.value) || [];
+  values = [...new Set(values)];
+
+  return {
+    ...productOption,
+    availableForSale,
+    name,
+    values
+  };
+};
+
+const reshapeProductVariant = (
+  productVariant: MedusaProductVariant,
+  productOptions?: MedusaProductOption[]
+): ProductVariant => {
+  let selectedOptions: SelectedOption[] = [];
+  if (productOptions && productVariant.options) {
+    const optionIdMap = mapOptionIds(productOptions);
+    selectedOptions = productVariant.options.map((option) => ({
+      name: optionIdMap[option.option_id] ?? '',
+      value: option.value
+    }));
+  }
+  const availableForSale = productVariant.purchasable || true;
+  const price = calculateVariantAmount(productVariant);
+
+  return {
+    ...productVariant,
+    availableForSale,
+    selectedOptions,
+    price
+  };
+};
+
+const reshapeCategory = (category: ProductCategory): ProductCollection => {
+  const description = category.description || category.metadata?.description?.toString() || '';
+  const seo = {
+    title: category?.metadata?.seo_title?.toString() || category.name || '',
+    description: category?.metadata?.seo_description?.toString() || category.description || ''
+  };
+  const path = `/search/${category.handle}`;
+  const updatedAt = category.updated_at;
+  const title = category.name;
+
+  return {
+    ...category,
+    description,
+    seo,
+    title,
+    path,
+    updatedAt
+  };
+};
+
+export async function createCart(): Promise<Cart> {
+  const res = await medusaRequest({ method: 'POST', path: '/carts' });
+  return reshapeCart(res.body.cart);
+}
+
+export async function addToCart(
+  cartId: string,
+  lineItem: { variantId: string; quantity: number }
+): Promise<Cart> {
+  const res = await medusaRequest({
+    method: 'POST',
+    path: `/carts/${cartId}/line-items`,
+    payload: {
+      variant_id: lineItem?.variantId,
+      quantity: lineItem?.quantity
+    },
+    tags: ['cart']
+  });
+  return reshapeCart(res.body.cart);
+}
+
+export async function removeFromCart(cartId: string, lineItemId: string): Promise<Cart> {
+  const res = await medusaRequest({
+    method: 'DELETE',
+    path: `/carts/${cartId}/line-items/${lineItemId}`,
+    tags: ['cart']
+  });
+  return reshapeCart(res.body.cart);
+}
+
+export async function updateCart(
+  cartId: string,
+  { lineItemId, quantity }: { lineItemId: string; quantity: number }
+): Promise<Cart> {
+  const res = await medusaRequest({
+    method: 'POST',
+    path: `/carts/${cartId}/line-items/${lineItemId}`,
+    payload: {
+      quantity
+    },
+    tags: ['cart']
+  });
+  return reshapeCart(res.body.cart);
+}
+
+export async function getCart(cartId: string): Promise<Cart | null> {
+  const res = await medusaRequest({ method: 'GET', path: `/carts/${cartId}`, tags: ['cart'] });
+  const cart = res.body.cart;
+
+  if (!cart) {
+    return null;
+  }
+
+  return reshapeCart(cart);
+}
+
+export async function getCategories(): Promise<ProductCollection[]> {
+  const res = await medusaRequest({
+    method: 'GET',
+    path: '/product-categories',
+    tags: ['categories']
+  });
+
+  // Reshape categories and hide categories starting with 'hidden'
+  const categories = res.body.product_categories
+    .map((collection: ProductCategory) => reshapeCategory(collection))
+    .filter((collection: MedusaProductCollection) => !collection.handle.startsWith('hidden'));
+
+  return categories;
+}
+
+export async function getCategory(handle: string): Promise<ProductCollection | undefined> {
+  const res = await medusaRequest({
+    method: 'GET',
+    path: `/product-categories?handle=${handle}&expand=products`,
+    tags: ['categories', 'products']
+  });
+  return res.body.product_categories[0];
+}
+
+export async function getCategoryProducts(
+  handle: string,
+  reverse?: boolean,
+  sortKey?: string
+): Promise<Product[]> {
+  const res = await medusaRequest({
+    method: 'GET',
+    path: `/product-categories?handle=${handle}`,
+    tags: ['categories']
+  });
+
+  if (!res) {
+    return [];
+  }
+
+  const category = res.body.product_categories[0];
+
+  const category_products = await getProducts({ reverse, sortKey, categoryId: category.id });
+
+  return category_products;
+}
+
+export async function getProduct(handle: string): Promise<Product> {
+  const res = await medusaRequest({
+    method: 'GET',
+    path: `/products?handle=${handle}&limit=1`,
+    tags: ['products']
+  });
+  const product = res.body.products[0];
+  return reshapeProduct(product);
+}
+
+export async function getProducts({
+  query,
+  reverse,
+  sortKey,
+  categoryId
+}: {
+  query?: string;
+  reverse?: boolean;
+  sortKey?: string;
+  categoryId?: string;
+}): Promise<Product[]> {
+  let res;
+
+  if (query) {
+    res = await medusaRequest({
+      method: 'GET',
+      path: `/products?q=${query}&limit=100`,
+      tags: ['products']
+    });
+  } else if (categoryId) {
+    res = await medusaRequest({
+      method: 'GET',
+      path: `/products?category_id[]=${categoryId}&limit=100`,
+      tags: ['products']
+    });
+  } else {
+    res = await medusaRequest({ method: 'GET', path: `/products?limit=100`, tags: ['products'] });
+  }
+
+  if (!res) {
+    console.error("Couldn't fetch products");
+    return [];
+  }
+
+  let products: Product[] = res?.body.products.map((product: MedusaProduct) =>
+    reshapeProduct(product)
+  );
+
+  sortKey === 'PRICE' &&
+    products.sort(
+      (a, b) =>
+        parseFloat(a.priceRange.maxVariantPrice.amount) -
+        parseFloat(b.priceRange.maxVariantPrice.amount)
+    );
+
+  sortKey === 'CREATED_AT' &&
+    products.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+
+  reverse && products.reverse();
+
+  return products;
+}
+
+export async function getMenu(menu: string): Promise<any[]> {
+  if (menu === 'next-js-frontend-header-menu') {
+    const categories = await getCategories();
+    return categories.map((cat) => ({
+      title: cat.title,
+      path: cat.path
+    }));
+  }
+
+  if (menu === 'next-js-frontend-footer-menu') {
+    return [
+      { title: 'About Medusa', path: 'https://medusajs.com/' },
+      { title: 'Medusa Docs', path: 'https://docs.medusajs.com/' },
+      { title: 'Medusa Blog', path: 'https://medusajs.com/blog' }
+    ];
+  }
+
+  return [];
+}
+
+// This is called from `app/api/revalidate.ts` so providers can control revalidation logic.
+export async function revalidate(req: NextRequest): Promise<NextResponse> {
+  // We always need to respond with a 200 status code to Medusa,
+  // otherwise it will continue to retry the request.
+  const collectionWebhooks = ['categories/create', 'categories/delete', 'categories/update'];
+  const productWebhooks = ['products/create', 'products/delete', 'products/update'];
+  const topic = headers().get('x-medusa-topic') || 'unknown';
+  const secret = req.nextUrl.searchParams.get('secret');
+  const isCollectionUpdate = collectionWebhooks.includes(topic);
+  const isProductUpdate = productWebhooks.includes(topic);
+
+  if (!secret || secret !== process.env.MEDUSA_REVALIDATION_SECRET) {
+    console.error('Invalid revalidation secret.');
+    return NextResponse.json({ status: 200 });
+  }
+
+  if (!isCollectionUpdate && !isProductUpdate) {
+    // We don't need to revalidate anything for any other topics.
+    return NextResponse.json({ status: 200 });
+  }
+
+  if (isCollectionUpdate) {
+    revalidateTag(TAGS.categories);
+  }
+
+  if (isProductUpdate) {
+    revalidateTag(TAGS.products);
+  }
+
+  return NextResponse.json({ status: 200, revalidated: true, now: Date.now() });
+}
diff --git a/lib/medusa/type-guards.ts b/lib/medusa/type-guards.ts
new file mode 100644
index 0000000..ec44cba
--- /dev/null
+++ b/lib/medusa/type-guards.ts
@@ -0,0 +1,27 @@
+
+export interface MedusaErrorLike {
+  status: number;
+  message: Error;
+}
+
+export const isObject = (object: unknown): object is Record<string, unknown> => {
+  return typeof object === 'object' && object !== null && !Array.isArray(object);
+};
+
+export const isMedusaError = (error: unknown): error is MedusaErrorLike => {
+  if (!isObject(error)) return false;
+
+  if (error instanceof Error) return true;
+
+  return findError(error);
+};
+
+function findError<T extends object>(error: T): boolean {
+  if (Object.prototype.toString.call(error) === '[object Error]') {
+    return true;
+  }
+
+  const prototype = Object.getPrototypeOf(error) as T | null;
+
+  return prototype === null ? false : findError(prototype);
+}
diff --git a/lib/medusa/types.ts b/lib/medusa/types.ts
new file mode 100644
index 0000000..7f1d2e6
--- /dev/null
+++ b/lib/medusa/types.ts
@@ -0,0 +1,433 @@
+export type MedusaProductCollection = {
+  name: any;
+  description: string | undefined;
+  id: string;
+  title: string;
+  handle: string;
+  products?: Product[];
+  created_at: string; // format: date-time
+  updated_at: string; // format: date-time
+  deleted_at?: string | null; // format: date-time
+  metadata?: Record<string, unknown> | null;
+};
+
+export type ProductCollection = MedusaProductCollection & {
+  seo?: {
+    title?: string;
+    description?: string;
+  };
+  path: string;
+  updatedAt: string;
+};
+
+export type MedusaProduct = {
+  id: string;
+  title: string;
+  subtitle?: string | null;
+  description?: string | null;
+  handle?: string | null;
+  is_giftcard: boolean;
+  status?: 'draft' | 'proposed' | 'published' | 'rejected';
+  images?: Array<MedusaImage>;
+  thumbnail?: string | null;
+  options?: Array<MedusaProductOption>;
+  variants: Array<MedusaProductVariant>;
+  categories?: Array<ProductCategory>;
+  profile_id?: string | null;
+  profile?: ShippingProfile | null;
+  weight?: number | null;
+  length?: number | null;
+  height?: number | null;
+  width?: number | null;
+  hs_code?: string | null;
+  origin_country?: string | null;
+  mid_code?: string | null;
+  metadata?: Record<string, any>;
+  discountable?: boolean;
+  collection_id: string;
+  created_at: Date;
+  updated_at: Date;
+  deleted_at: Date | null;
+  type_id: string;
+  material?: string | null;
+  tags?: ProductTag[];
+};
+
+export type Product = Partial<Omit<MedusaProduct, 'tags' | 'options' | 'variants'>> & {
+  title: string;
+  featuredImage: FeaturedImage;
+  seo?: {
+    title?: string;
+    description?: string;
+  };
+  priceRange: {
+    maxVariantPrice: Money;
+  };
+  createdAt: Date;
+  updatedAt: Date;
+  descriptionHtml: string;
+  tags: Array<string>;
+  availableForSale: boolean;
+  options: Array<ProductOption>;
+  variants: Array<ProductVariant>;
+  images?: Array<Image>;
+};
+
+export type FeaturedImage = {
+  url: string;
+  width?: number;
+  height?: number;
+  altText: string;
+};
+
+export type ProductTag = {
+  id: string;
+  value: string;
+  created_at: string;
+  updated_at: string;
+  deleted_at: string | null;
+  metadata?: Record<string, unknown> | null;
+};
+
+export type MedusaImage = {
+  id: string;
+  url: string;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: { [key: string]: string } | null;
+};
+
+export type Image = MedusaImage & {
+  altText: string;
+};
+
+export type ShippingProfile = {
+  id: string;
+  name: string;
+  type: 'default' | 'gift_card' | 'custom';
+  products?: Product[];
+  shipping_options?: ShippingOption[];
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: { [key: string]: any } | null;
+};
+
+export type ProductCategory = {
+  id: string;
+  name: string;
+  description: string;
+  handle: string;
+  mpath: string | null;
+  is_internal?: boolean;
+  is_active?: boolean;
+  rank?: number;
+  category_children?: ProductCategory[];
+  parent_category_id?: string | null;
+  parent_category?: ProductCategory | null;
+  products?: Product[];
+  created_at: string;
+  updated_at: string;
+  metadata?: { [key: string]: string } | null;
+};
+
+export type MedusaProductVariant = {
+  id: string;
+  title?: string;
+  product_id: string;
+  product?: Product;
+  prices?: MoneyAmount[];
+  sku?: string;
+  barcode?: string | null;
+  ean?: string | null;
+  upc?: string | null;
+  variant_rank?: number | null;
+  inventory_quantity: number;
+  allow_backorder: boolean;
+  manage_inventory: boolean;
+  hs_code?: string | null;
+  origin_country?: string | null;
+  mid_code?: string | null;
+  material?: string | null;
+  weight?: number | null;
+  length?: number | null;
+  height?: number | null;
+  width?: number | null;
+  options?: ProductOptionValue[];
+  created_at: string;
+  updated_at: string;
+  deleted_at: string | null;
+  purchasable?: boolean;
+};
+
+export type ProductVariant = MedusaProductVariant & {
+  availableForSale: boolean;
+  selectedOptions: SelectedOption[];
+  price: Money;
+};
+
+export type SelectedOption = {
+  name: string;
+  value: string;
+};
+
+export type MedusaProductOption = {
+  id: string;
+  title: string;
+  values?: ProductOptionValue[];
+  product_id: string;
+  product?: Product | null;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: Record<string, any> | null;
+};
+
+export type ProductOption = Omit<MedusaProductOption, 'values'> & {
+  availableForSale: boolean;
+  name: string;
+  values: string[];
+};
+
+export type ProductOptionValue = {
+  id: string;
+  value: string;
+  option_id: string;
+  option?: MedusaProductOption | null;
+  variant_id: string;
+  variant?: MedusaProductVariant | null;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: Record<string, any> | null;
+};
+
+export type Money = {
+  amount: string;
+  currencyCode: string;
+};
+
+export type MoneyAmount = {
+  id: string;
+  currency_code: string;
+  currency?: Currency | null;
+  amount: number;
+  min_quantity?: number | null;
+  max_quantity?: number | null;
+  price_list_id?: string | null;
+  price_list?: PriceList | null;
+  variant_id?: string | null;
+  variant?: ProductVariant | null;
+  region_id?: string | null;
+  region?: Region | null;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+};
+
+export type Currency = {
+  code: string;
+  symbol: string;
+  symbol_native: string;
+  name: string;
+  includes_tax?: boolean;
+};
+
+export type PriceList = {
+  id: string;
+  name: string;
+  description: string;
+  type?: 'sale' | 'override';
+  status?: 'active' | 'draft';
+  starts_at?: string | null;
+  ends_at?: string | null;
+  customer_groups?: CustomerGroup[];
+  prices?: MoneyAmount[];
+  includes_tax?: boolean;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+};
+
+export type CustomerGroup = {
+  id: string;
+  name: string;
+};
+
+type ShippingOption = {
+  id: string;
+  name: string;
+  region_id: string;
+  region?: Region | null;
+  profile_id: string;
+  profile?: ShippingProfile | null;
+  provider_id: string;
+  provider?: FulfillmentProvider | null;
+  price_type: 'flat_rate' | 'calculated';
+  amount?: number | null;
+  is_return: boolean;
+  admin_only: boolean;
+  requirements?: ShippingOptionRequirement[];
+  data: Record<string, unknown>;
+  includes_tax: boolean;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: Record<string, unknown> | null;
+};
+
+export type Region = {
+  id: string;
+  name: string;
+  country_code: string;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: Record<string, unknown> | null;
+  currency_code: string;
+  tax_code: string;
+  tax_rate: number;
+};
+
+export type FulfillmentProvider = {
+  id: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: Record<string, unknown> | null;
+};
+
+export type ShippingOptionRequirement = {
+  id: string;
+  requirement_id: string;
+  value: string;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string | null;
+  metadata?: Record<string, unknown> | null;
+};
+
+export type MedusaCart = {
+  id: string;
+  email?: string;
+  billing_address_id: string;
+  // billing_address?: Address;
+  // shipping_address_id?: string;
+  // shipping_address?: Address;
+  items?: MedusaLineItem[];
+  region_id: string;
+  region?: Region;
+  // discounts?: Discount[];
+  // gift_cards?: GiftCard[];
+  customer_id?: string;
+  // customer?: Customer;
+  // payment_session?: PaymentSession;
+  // payment_sessions?: PaymentSession[];
+  payment_id?: string;
+  // payment?: Payment;
+  // shipping_methods?: ShippingMethod[];
+  type: 'default' | 'swap' | 'draft_order' | 'payment_link' | 'claim';
+  completed_at?: string;
+  payment_authorized_at?: string;
+  idempotency_key?: string;
+  context?: Record<string, any>;
+  sales_channel_id?: string;
+  // sales_channel?: SalesChannel;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string;
+  metadata?: Record<string, any>;
+  shipping_total?: number;
+  discount_total?: number;
+  raw_discount_total?: number;
+  item_tax_total?: number;
+  shipping_tax_total?: number;
+  tax_total?: number;
+  refunded_total?: number;
+  total?: number;
+  subtotal?: number;
+};
+
+export type Cart = Partial<MedusaCart> & {
+  lines: CartItem[];
+  checkoutUrl: string;
+  totalQuantity: number;
+  cost: {
+    subtotalAmount: Money;
+    totalAmount: Money;
+    totalTaxAmount: Money;
+  };
+};
+
+export type Menu = {
+  title: string;
+  path: string;
+};
+
+export type MedusaLineItem = {
+  id: string;
+  cart_id?: string;
+  cart?: Cart;
+  order_id?: string;
+  // order?: Order;
+  swap_id?: string | null;
+  // swap?: Swap;
+  claim_order_id?: string | null;
+  // claim_order?: ClaimOrder;
+  // tax_lines?: LineItemTaxLine[];
+  // adjustments?: LineItemAdjustment[];
+  original_item_id?: string | null;
+  order_edit_id?: string | null;
+  // order_edit?: OrderEdit;
+  title: string;
+  description?: string | null;
+  thumbnail?: string | null;
+  is_return: boolean;
+  is_giftcard: boolean;
+  should_merge: boolean;
+  allow_discounts: boolean;
+  has_shipping?: boolean | null;
+  unit_price: number;
+  variant_id?: string | null;
+  variant: MedusaProductVariant;
+  quantity: number;
+  fulfilled_quantity?: number | null;
+  returned_quantity?: number | null;
+  shipped_quantity?: number | null;
+  refundable: number;
+  subtotal: number;
+  tax_total: number;
+  total: number;
+  original_total: number;
+  original_tax_total: number;
+  discount_total: number;
+  raw_discount_total: number;
+  gift_card_total: number;
+  includes_tax: boolean;
+  created_at: Date;
+  updated_at: Date;
+  metadata?: { [key: string]: string } | null;
+};
+
+export type CartItem = MedusaLineItem & {
+  merchandise: {
+    id: string;
+    selectedOptions: SelectedOption[];
+    product: Product;
+    title: string;
+  };
+  cost: {
+    totalAmount: Money;
+  };
+  quantity: number;
+};
+
+export type RegionInfo = Pick<Region, 'currency_code' | 'tax_code' | 'tax_rate'>;
+export type ProductVariantEntity = ConvertDateToString<Omit<ProductVariant, 'beforeInsert'>>;
+export type ProductVariantInfo = Pick<ProductVariantEntity, 'prices'>;
+
+type ConvertDateToString<T extends {}> = {
+  [P in keyof T]: T[P] extends Date ? Date | string : T[P];
+};
diff --git a/lib/medusa/utils.ts b/lib/medusa/utils.ts
new file mode 100644
index 0000000..b579fbc
--- /dev/null
+++ b/lib/medusa/utils.ts
@@ -0,0 +1,31 @@
+import { ReadonlyURLSearchParams } from 'next/navigation';
+import { MedusaProductOption } from './types';
+
+export const createUrl = (pathname: string, params: URLSearchParams | ReadonlyURLSearchParams) => {
+  const paramsString = params.toString();
+  const queryString = `${paramsString.length ? '?' : ''}${paramsString}`;
+
+  return `${pathname}${queryString}`;
+};
+
+export const mapOptionIds = (productOptions: MedusaProductOption[]) => {
+  // Maps the option titles to their respective ids
+  const map: Record<string, string> = {};
+  productOptions.forEach((option) => {
+    map[option.id] = option.title;
+  });
+  return map;
+};
+
+export const isObject = (input: any) => input instanceof Object;
+export const isArray = (input: any) => Array.isArray(input);
+
+export const isEmpty = (input: any) => {
+  return (
+    input === null ||
+    input === undefined ||
+    (isObject(input) && Object.keys(input).length === 0) ||
+    (isArray(input) && (input as any[]).length === 0) ||
+    (typeof input === 'string' && input.trim().length === 0)
+  );
+};
\ No newline at end of file
diff --git a/lib/constants.ts b/lib/shopify/constants.ts
similarity index 100%
rename from lib/constants.ts
rename to lib/shopify/constants.ts
diff --git a/lib/shopify/index.ts b/lib/shopify/index.ts
index 0dc797e..504aeb0 100644
--- a/lib/shopify/index.ts
+++ b/lib/shopify/index.ts
@@ -1,6 +1,6 @@
-import { HIDDEN_PRODUCT_TAG, SHOPIFY_GRAPHQL_API_ENDPOINT, TAGS } from 'lib/constants';
-import { isShopifyError } from 'lib/type-guards';
-import { ensureStartsWith } from 'lib/utils';
+import { ensureStartsWith } from '@/lib/shopify/utils';
+import { HIDDEN_PRODUCT_TAG, SHOPIFY_GRAPHQL_API_ENDPOINT, TAGS } from './constants';
+import { isShopifyError } from './type-guards';
 import {
   addToCartMutation,
   createCartMutation,
diff --git a/lib/shopify/revalidate.ts b/lib/shopify/revalidate.ts
index a1b4ea9..2120b02 100644
--- a/lib/shopify/revalidate.ts
+++ b/lib/shopify/revalidate.ts
@@ -1,7 +1,7 @@
 import { revalidateTag } from 'next/cache';
 import { headers } from 'next/headers';
 import { NextRequest, NextResponse } from 'next/server';
-import { TAGS } from '../constants';
+import { TAGS } from './constants';
 
 // This is called from `app/api/revalidate.ts` so providers can control revalidation logic.
 export async function revalidate(req: NextRequest): Promise<NextResponse> {
diff --git a/lib/type-guards.ts b/lib/shopify/type-guards.ts
similarity index 100%
rename from lib/type-guards.ts
rename to lib/shopify/type-guards.ts
diff --git a/lib/utils.ts b/lib/shopify/utils.ts
similarity index 100%
rename from lib/utils.ts
rename to lib/shopify/utils.ts
diff --git a/tsconfig.json b/tsconfig.json
index 20e8b55..26bbc56 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,11 +1,7 @@
 {
   "compilerOptions": {
     "target": "es2015",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
+    "lib": ["dom", "dom.iterable", "esnext"],
     "downlevelIteration": true,
     "allowJs": true,
     "skipLibCheck": true,
@@ -27,9 +23,7 @@
       }
     ],
     "paths": {
-      "@/*": [
-        "./*"
-      ]
+      "@/*": ["./*"]
     }
   },
   "include": [
@@ -38,9 +32,8 @@
     "**/*.tsx",
     ".next/types/**/*.ts",
     "app/page.tsx_",
-    "app/(frontend)/[[...page]]/opengraph-image.tsx_"
-, "app/(frontend)/opengraph-image.tsx_"  ],
-  "exclude": [
-    "node_modules"
-  ]
-}
\ No newline at end of file
+    "app/(frontend)/[[...page]]/opengraph-image.tsx_",
+    "app/(frontend)/opengraph-image.tsx_"
+  ],
+  "exclude": ["node_modules"]
+}