@evenicanpm/storefront-core 1.0.0-alpha

package/src/api-manager/datasources/e4/utils/unwrap-e4-variants.ts

@@ -0,0 +1,65 @@
+import { merge } from "object-mapper";
+import { Attributes, Maybe, Variants } from "../graphqlRequestSdk";
+import { dimensionMap } from "../e4.remaps";
+
+type DimensionValue = {
+  Value: string;
+  RecordId: string;
+};
+
+type UnwrappedAttribute = {
+  DimensionTypeValue: string;
+  DimensionValue: DimensionValue;
+  TotalAvailableInventoryLevelCode: string;
+  ProductIds: string[];
+};
+
+/**
+ * Unwraps an E4 Product variant and converts it
+ * to D365 Dimension Data Structure
+ * @param variants an e4 product variant
+ * @returns [][]
+ */
+export default function unwrapE4Variants(
+  variants: Variants[],
+): UnwrappedAttribute[][] {
+  if (!(variants && variants?.length)) return [];
+  const attrs: UnwrappedAttribute[] = variants.flatMap(
+    (v) =>
+      v.Attributes?.map((attr: Maybe<Attributes>) => {
+        const dimension = attr ? merge(attr, dimensionMap) : null;
+
+        if (!dimension) return null;
+
+        return {
+          ...dimension,
+          ProductIds: [v.ProductId],
+        } as UnwrappedAttribute;
+      }).filter(Boolean) as UnwrappedAttribute[],
+  );
+
+  const grouped: UnwrappedAttribute[][] = attrs.reduce((acc, item) => {
+    const group = acc.find(
+      (group) => group[0]?.DimensionTypeValue === item.DimensionTypeValue,
+    );
+
+    if (!group) {
+      acc.push([item]);
+    } else {
+      const existingDimension = group.find(
+        (attribute) =>
+          attribute.DimensionValue.Value === item.DimensionValue.Value,
+      );
+
+      if (!existingDimension) {
+        group.push(item);
+      } else if (!existingDimension.ProductIds.includes(item.ProductIds[0])) {
+        existingDimension.ProductIds.push(item.ProductIds[0]);
+      }
+    }
+
+    return acc;
+  }, [] as UnwrappedAttribute[][]);
+
+  return grouped;
+}

package/src/api-manager/index.ts

@@ -0,0 +1,71 @@
+import { Datasource, DatasourceApis } from "./types/Datasource";
+import E4Datasource from "./datasources/e4/e4.datasource";
+import { D365Datasource } from "./datasources/d365/index";
+import rawConfig from "./api-manager.config.json";
+import { z } from "zod";
+import { getContextFromCookie } from "./datasources/d365/utils/get-context-cookie";
+type EntityNames = keyof DatasourceApis;
+
+interface Config {
+  primary: string;
+  secondary: string[];
+  overrides?: Partial<Record<EntityNames, string>>;
+}
+
+const Config = z.object({
+  primary: z.string(),
+  secondary: z.array(z.string()),
+  overrides: z.record(z.string(), z.string()),
+});
+
+/**
+ * Loads up all specified apis/datasources based on parsed config
+ * and returns the ApiManager object.
+ * @returns ApiManager object.
+ */
+async function createApiManager() {
+  try {
+    Config.parse(rawConfig);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      error.issues;
+    }
+  }
+
+  const context = await getContextFromCookie();
+  const datasourceMap: Record<string, Datasource> = {
+    d365: new D365Datasource("d365", context),
+    e4: E4Datasource,
+    // Add more datasources here as needed
+  };
+
+  const config = rawConfig as Config;
+  const primaryDatasource = datasourceMap[config.primary];
+  const secondaryDatasources = config.secondary.map(
+    (name) => datasourceMap[name],
+  );
+
+  const getDatasource = (entityName: EntityNames) => {
+    const override = config?.overrides?.[entityName];
+    if (override) {
+      return (
+        secondaryDatasources.find((ds) => ds.name === override) ??
+        primaryDatasource
+      );
+    }
+    return primaryDatasource;
+  };
+
+  return {
+    user: getDatasource("user").user,
+    session: getDatasource("session").session,
+    cart: getDatasource("cart").cart,
+    product: getDatasource("product").product,
+    categories: getDatasource("categories").categories,
+    order: getDatasource("order").order,
+    address: getDatasource("address").address,
+    organization: getDatasource("organization").organization,
+  };
+}
+
+export default createApiManager;

package/src/api-manager/lib/cart-cookie-handler.ts

@@ -0,0 +1,14 @@
+"use server";
+import { cookies } from "next/headers";
+
+const getCartCookie = async () => (await cookies()).get("cart_cookie")?.value;
+
+const setCartCookie = async (cartId: string) => {
+  (await cookies()).set("cart_cookie", cartId);
+};
+
+const deleteCartCookie = async () => {
+  (await cookies()).delete("cart_cookie");
+};
+
+export { getCartCookie, setCartCookie, deleteCartCookie };

package/src/api-manager/lib/category-helpers.ts

@@ -0,0 +1,113 @@
+import {
+  Category,
+  TextValueTranslation,
+} from "@msdyn365-commerce/retail-proxy";
+
+export interface CategoryHierarchy extends Category {
+  Children: CategoryHierarchy[];
+  Slug?: string;
+  Url?: string;
+  NeutralizedName?: string;
+  IsCMSPage?: boolean;
+}
+
+export type CategoryMap = {
+  [RecordId: number]: CategoryHierarchy;
+};
+
+const mapCategoryToHierarchy = (
+  categoryList: Category[],
+  locale?: string,
+  includeRootCategory?: boolean,
+): CategoryHierarchy[] => {
+  if (!categoryList || categoryList.length === 0) {
+    return [];
+  }
+
+  const categoryMap: CategoryMap = {};
+
+  for (const category of categoryList) {
+    const localName = getFriendlyName(locale, category.NameTranslations);
+    const categoryHierarchy = <CategoryHierarchy>{ ...category };
+    categoryHierarchy.NeutralizedName = category.Name;
+    categoryHierarchy.Name = localName || categoryHierarchy.NeutralizedName;
+    // Derive Slug from Url or Name for D365
+    categoryHierarchy.Slug =
+      (category as CategoryHierarchy).Url?.split("/")
+        .pop()
+        ?.replace(/\d+$/, "") || normalizeCategoryName(category?.Name ?? "");
+    categoryMap[category.RecordId] = categoryHierarchy;
+  }
+
+  let rootCategory: CategoryHierarchy | undefined;
+  for (const category of Object.values(categoryMap)) {
+    const parentId = category.ParentCategory;
+    if (!category.Url) {
+      category.Url = generateUrl(categoryList, category, locale || "");
+    }
+    if (parentId === 0) {
+      rootCategory = category;
+      continue;
+    }
+
+    const parent = parentId && categoryMap[parentId];
+    if (parent) {
+      parent.Children = parent.Children || [];
+      parent.Children.push(category);
+    }
+  }
+
+  if (!rootCategory) {
+    return [];
+  }
+
+  if (includeRootCategory) {
+    const categoryHierarchy: CategoryHierarchy[] = [];
+    categoryHierarchy.push(rootCategory);
+    return categoryHierarchy;
+  }
+
+  return rootCategory.Children ?? [];
+};
+
+const generateUrl = (
+  categoryHierarchy: Category[],
+  currentCategory: CategoryHierarchy,
+  locale: string,
+) => {
+  const categoryNames: string[] = [];
+  let nextCat: CategoryHierarchy | Category | undefined = currentCategory;
+  while (nextCat) {
+    const catName =
+      getFriendlyName(locale, nextCat.NameTranslations) || nextCat.Name || "";
+    categoryNames.push(normalizeCategoryName(catName));
+    nextCat = categoryHierarchy.find(
+      (c) => c.RecordId === nextCat?.ParentCategory,
+    );
+  }
+  categoryNames.unshift(currentCategory.RecordId.toString());
+  return categoryNames.reverse().join("/");
+};
+
+const getFriendlyName = (
+  locale?: string,
+  nameTranslations?: TextValueTranslation[],
+): string | undefined => {
+  let nameTranslation: TextValueTranslation | undefined;
+  if (locale && nameTranslations && nameTranslations.length > 0) {
+    nameTranslation = nameTranslations.find(
+      (item) => item?.Language?.toLowerCase() === locale?.toLowerCase(),
+    );
+  }
+  return nameTranslation && nameTranslation.Text;
+};
+
+const normalizeCategoryName = (string_: string) =>
+  string_.toLowerCase().replaceAll(" ", "-");
+
+export {
+  mapCategoryToHierarchy,
+  generateUrl,
+  getFriendlyName,
+  normalizeCategoryName,
+};

package/src/api-manager/lib/get-dynamics-context.ts

@@ -0,0 +1,34 @@
+import { ICallerContext } from "@msdyn365-commerce/retail-proxy";
+
+export const getDynamicsContext = (
+  channelConfig: ChannelConfiguration,
+  token?: string,
+): ICallerContext => {
+  const { channelId, operatingUnitNumber, retailServerUrl, locale } =
+    channelConfig;
+
+  return {
+    requestContext: {
+      locale,
+      apiSettings: {
+        baseUrl: retailServerUrl,
+        channelId: Number(channelId),
+        oun: operatingUnitNumber,
+        catalogId: 0,
+        baseImageUrl: "",
+      },
+      user: {
+        isAuthenticated: !!token,
+        token: token || "",
+      },
+      operationId: crypto.randomUUID(),
+    },
+  };
+};
+
+export type ChannelConfiguration = {
+  locale: string;
+  retailServerUrl: string;
+  channelId: number;
+  operatingUnitNumber: string;
+};

package/src/api-manager/lib/get-graphql-client.test.ts

@@ -0,0 +1,106 @@
+//import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getServerSession } from "next-auth/next";
+import { cookies } from "next/headers";
+import getGraphQLClient from "./get-graphql-client";
+
+// TODO: FIX THESE TESTS
+//
+//const mockSetHeaders = vi.fn();
+// const mockGraphQLClientInstance = { setHeaders: mockSetHeaders };
+
+/*
+vi.mock("graphql-request", () => ({
+  GraphQLClient: vi.fn(() => mockGraphQLClientInstance),
+}));
+
+vi.mock("@/api-manager/datasources/e4/graphqlRequestSdk", () => ({
+  getSdk: vi.fn(() => "mockSDK"),
+}));
+
+vi.mock("next-auth/next", () => ({
+  getServerSession: vi.fn(),
+}));
+
+vi.mock("@a/api/auth/[...nextauth]/auth-options", () => ({
+  default: {},
+}));
+
+vi.mock("next/headers", () => ({
+  cookies: vi.fn(),
+}));
+
+describe("getGraphQLClient", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("initializes GraphQL client without authentication", async () => {
+    (cookies as unknown as vi.Mock).mockReturnValue({
+      get: vi.fn().mockReturnValue(null),
+    });
+
+    const sdk = await getGraphQLClient();
+
+    expect(mockSetHeaders).toHaveBeenCalledWith({
+      "client-name": "storefront",
+      "client-version": "0.1.0",
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    });
+    expect(sdk).toBe("mockSDK");
+  });
+
+  it("includes storefront session cookie if available", async () => {
+    (cookies as unknown as vi.Mock).mockReturnValue({
+      get: vi.fn().mockReturnValue({ value: "mockSessionCookie" }),
+    });
+
+    const sdk = await getGraphQLClient();
+
+    expect(mockSetHeaders).toHaveBeenCalledWith(
+      expect.objectContaining({
+        Cookie: "storefront=mockSessionCookie",
+      }),
+    );
+    expect(sdk).toBe("mockSDK");
+  });
+
+  it("includes authorization token when withAuth is true", async () => {
+    (cookies as unknown as vi.Mock).mockReturnValue({
+      get: vi.fn().mockReturnValue(null),
+    });
+
+    (getServerSession as vi.Mock).mockResolvedValue({
+      accessToken: "mockAccessToken",
+    });
+
+    const sdk = await getGraphQLClient(true);
+
+    expect(getServerSession).toHaveBeenCalled();
+    expect(mockSetHeaders).toHaveBeenCalledWith(
+      expect.objectContaining({
+        Authorization: "Bearer mockAccessToken",
+      }),
+    );
+    expect(sdk).toBe("mockSDK");
+  });
+
+  it("does not include authorization token if session is missing", async () => {
+    (cookies as unknown as vi.Mock).mockReturnValue({
+      get: vi.fn().mockReturnValue(null),
+    });
+
+    (getServerSession as vi.Mock).mockResolvedValue(null);
+
+    const sdk = await getGraphQLClient(true);
+
+    expect(getServerSession).toHaveBeenCalled();
+    expect(mockSetHeaders).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        Authorization: expect.any(String),
+      }),
+    );
+    expect(sdk).toBe("mockSDK");
+  });
+});
+*/

package/src/api-manager/lib/get-graphql-client.ts

@@ -0,0 +1,53 @@
+"use server";
+
+import { GraphQLClient } from "graphql-request";
+import { getSdk } from "../datasources/e4/graphqlRequestSdk";
+import { getServerSession } from "next-auth/next";
+// TODO: Get auth inside client packages
+import authOptions from "@/auth/auth-options";
+import { cookies } from "next/headers";
+
+const API_URL = process.env.REACT_APP_E4_API_ENDPOINT; //`https://api.e4.local/graphql`;
+
+/**
+ * Initializes and returns a cached GraphQL client
+ * @param withAuth (optional) - If true, includes the authorization token
+ * @returns GraphQL SDK instance
+ */
+const getGraphQLClient = async (withAuth = false) => {
+  const headers: Record<string, string> = {
+    "client-name": "storefront",
+    "client-version": "0.1.0",
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+
+  const cookieStore = await cookies();
+  const sessionCookie = cookieStore.get("storefront"); // cookie is set in middleware - setE4SessionCookies
+  // This session cookie solution only works when all api calls are through server actions.
+  // If not we need to route all e4 client api calls through an custom api route.
+  if (sessionCookie) {
+    headers["Cookie"] = `storefront=${sessionCookie.value}`;
+  }
+
+  if (withAuth) {
+    const session = await getServerSession(authOptions());
+    // @ts-ignore
+    if (session && session?.accessToken) {
+      // @ts-ignore
+      headers["Authorization"] = `Bearer ${session.accessToken}`;
+    }
+  }
+
+  // Best Practice: Never reuse a GraphQL client that mutates headers across different requests in server environments.
+  // When we resuse the client instance, sometimes the token is missing in e4 backend.
+  const client = new GraphQLClient(API_URL, {
+    headers,
+    credentials: "include",
+  });
+
+  client.setHeaders(headers);
+  return getSdk(client);
+};
+
+export default getGraphQLClient;

package/src/api-manager/schemas/README.md

@@ -0,0 +1,12 @@
+# Schemas
+
+- Contains all the base models that datasource data fetching/mutating must output.
+- The reason it is stored in it's own folder is because it is data source agnostic and should not belong to any one data source
+- <entity>.schema.ts are the input and output validation schemas for each entity
+- `d365.schema.ts` is generated from ts-to-zod to provide schemas for all d365 entities in the retail-proxy library.
+- to re-run codegen of schemas run `npm run generate-schemas`
+- Now that we have decided to use the generated schemas for the entity types, the `<entity>.schema.ts` files will contain mostly input types for mutations
+
+## Output types
+
+- We should try to use the default schemas from D3565 as much as possible, if we encounter a unique situation or if there a lot of bloat properties on D365 type that do not exist in E4 then create a custom entity schema.

package/src/api-manager/schemas/address.schema.ts

@@ -0,0 +1,46 @@
+import z from "zod";
+import { addressSchema } from "./d365.schema";
+
+export const addressTypeSchema = z
+  .object({
+    Id: z.string(),
+    Name: z.string().optional(),
+    DisplayName: z.string().optional(),
+  })
+  .optional();
+
+// export const addressSchema = z.object({
+//     Id:z.string().optional(),
+//     Name:z.string().optional(),
+//     FirstName: z.string().optional(),
+//     LastName: z.string().optional(),
+//     IsPrimary:z.boolean().optional(),
+//     AddressType: addressTypeSchema,
+//     AddressLine1: z.string().optional(),
+//     AddressLine2: z.string().optional(),
+//     City: z.string().optional(),
+//     StateId: z.string().optional(),
+//     StateName: z.string().optional(),
+//     CountryId: z.string().optional(),
+//     CountryName: z.string().optional(),
+//     CountryCode: z.string().optional(),
+//     ZipCode: z.string().optional(),
+//     Phone: z.string().optional(),
+// });
+
+const getCountriesInput = z.object({
+  locale: z.string().optional(),
+});
+const getStatesInput = z.object({
+  countryId: z.string().optional(),
+});
+
+const getDeliveryOptionsInput = z.object({
+  cartId: z.string(),
+  shippingAddress: addressSchema,
+  cartLineIds: z.array(z.string()),
+});
+export type GetCountriesInput = z.infer<typeof getCountriesInput>;
+export type GetStatesInput = z.infer<typeof getStatesInput>;
+export type GetDeliveryOptionsInput = z.infer<typeof getDeliveryOptionsInput>;
+export type Address = z.infer<typeof addressSchema>;

package/src/api-manager/schemas/cart.schema.ts

@@ -0,0 +1,92 @@
+import z from "zod";
+import {
+  cartLineDeliveryPreferenceSchema,
+  cartLineSchema,
+  cartSchema,
+  retrievePaymentResultSettingsSchema,
+  simpleProductSchema,
+  tokenizedPaymentCardSchema,
+} from "./d365.schema";
+
+const extendedCartLineSchema = cartLineSchema.extend({
+  Product: simpleProductSchema.optional(),
+});
+
+export const extendedCartSchema = cartSchema
+  .omit({ CartLines: true })
+  .extend({ CartLines: extendedCartLineSchema.array() });
+
+// input
+export const modifyOrAddCartLineInput = z.object({
+  cartLine: z.custom<CartLine>().array(),
+  cartId: z.string().optional(),
+  version: z.number().optional(),
+});
+
+export const updateCartInput = z.object({
+  cart: extendedCartSchema.partial(),
+});
+
+export const getCartInput = z.object({
+  cartId: z.string().optional(),
+});
+
+export const manageDiscountCodeInput = z.object({
+  cartId: z.string().optional(),
+  discountCode: z.string(),
+});
+
+export const retrieveCardPaymentAcceptResultInput = z.object({
+  cartId: z.string(),
+  resultAccessCode: z.string(),
+  settings: retrievePaymentResultSettingsSchema,
+});
+
+export const getCardAcceptPointInput = z.object({
+  cartId: z.string(),
+  hideBillingAddress: z.boolean().optional(),
+  totalAmount: z.number(),
+  origin: z.string().optional(),
+  isClient: z.boolean(),
+});
+
+export const checkoutInput = z.object({
+  id: z.string(),
+  receiptEmail: z.string(),
+  tokenizedPaymentCard: tokenizedPaymentCardSchema,
+  currency: z.string(),
+  amount: z.number(),
+});
+
+export const updateCartLineDeliveryModeInput = z.object({
+  cartId: z.string(),
+  cartLineDeliverySpecification: cartLineDeliveryPreferenceSchema.array(),
+});
+
+export const removeCartLineDeliveryModeInput = z.object({
+  cart: extendedCartSchema.partial(),
+});
+
+// Typescript Types
+// export type Cart = z.infer<typeof cartSchema>;
+// export type CartLine = z.infer<typeof cartLineSchema>;
+export type AddToCartInput = z.infer<typeof modifyOrAddCartLineInput>;
+export type UpdateCartLineInput = z.infer<typeof modifyOrAddCartLineInput>;
+export type UpdateCartInput = z.infer<typeof updateCartInput>;
+export type DeleteCartLineInput = z.infer<typeof modifyOrAddCartLineInput>;
+export type ManageDiscountCodeInput = z.infer<typeof manageDiscountCodeInput>;
+export type Cart = z.infer<typeof extendedCartSchema>;
+export type CartLine = z.infer<typeof extendedCartLineSchema>;
+export type RetrieveCardPaymentAcceptResultInput = z.infer<
+  typeof retrieveCardPaymentAcceptResultInput
+>;
+export type GetCardPaymentAcceptPointInput = z.infer<
+  typeof getCardAcceptPointInput
+>;
+export type UpdateCartLineDeliveryModeInput = z.infer<
+  typeof updateCartLineDeliveryModeInput
+>;
+export type RemoveCartLineDeliveryModeInput = z.infer<
+  typeof removeCartLineDeliveryModeInput
+>;
+export type CheckoutInput = z.infer<typeof checkoutInput>;