@evenicanpm/storefront-core 1.0.0-alpha

package/src/api-manager/datasources/e4/e4.translator.ts

@@ -0,0 +1,648 @@
+// Schemas
+import { extendedCartSchema, Cart } from "@/api-manager/schemas/cart.schema";
+import {
+  productSchema,
+  ProductDetails,
+  SearchByCriteriaInput,
+} from "@/api-manager/schemas/product.schema";
+import { Address } from "@/api-manager/schemas/address.schema";
+import { User } from "@/api-manager/schemas/user.schema";
+import { Session } from "@/api-manager/schemas/session.schema";
+import { merge } from "object-mapper";
+import getGraphqlClient from "../../lib/get-graphql-client";
+// Interfaces
+import {
+  UserInput,
+  AddressInput,
+  Attribute,
+  Category as E4Category,
+  Country,
+  Shipping,
+  Cart as E4Cart,
+  Product,
+  Session as E4Session,
+} from "./graphqlRequestSdk";
+import {
+  Category,
+  ProductRefinerValue,
+  ProductSearchResult,
+} from "@msdyn365-commerce/retail-proxy";
+import {
+  cartMap,
+  productDetailsMap,
+  productMap,
+  addressReverseMap,
+  countriesMap,
+  countryMap,
+  deliveryOptionsMap,
+} from "./e4.remaps";
+import { CategoryHierarchy } from "@/lib/category-helpers";
+
+interface TransformedRefinerValue {
+  RefinerRecordId: number;
+  DataTypeValue: number;
+  LeftValueBoundString: string;
+  RightValueBoundString: string;
+  UnitText: string;
+  RowNumber: number;
+  Count: number;
+  LeftValueBoundLocalizedString: string;
+  RightValueBoundLocalizedString: string;
+  ExtensionProperties: [];
+  RefinerSourceValue: number;
+  SwatchImageUrl: string;
+  SwatchColorHexCode: string;
+  "@odata.type": string;
+}
+
+interface TransformedRefiner {
+  RecordId: number;
+  KeyName: string;
+  DataTypeValue: number;
+  RefinerTypeValue: number;
+  DisplayTemplateValue: number;
+  ExtensionProperties: [];
+  SourceValue: number;
+  Values: TransformedRefinerValue[];
+  IsDimension: boolean;
+  "@odata.type": string;
+}
+
+class RecordIdMapper {
+  private recordToAttr: Record<number, string> = {};
+
+  public add(recordId: number, attributeId: string) {
+    this.recordToAttr[recordId] = attributeId;
+  }
+
+  public getAttributeId(recordId: number): string | undefined {
+    return this.recordToAttr[recordId];
+  }
+}
+
+const RECORD_ID_MAPPER = new RecordIdMapper();
+
+export const generateCategoryFilterString = async (
+  targetCategoryIdNum: string | number,
+): Promise<string> => {
+  const e4Api = await getGraphqlClient();
+
+  let e4Categories: E4Category[] = [];
+  try {
+    const { data, errors: catErrors } = await e4Api.categories();
+    if (catErrors) {
+      console.error("Error fetching categories:", catErrors);
+    }
+    e4Categories = (data?.categories.category ?? []).filter(
+      (category) => category !== null,
+    ) as E4Category[];
+  } catch (error) {
+    console.error("Exception fetching categories:", error);
+  }
+
+  const targetCategoryIdStr = String(targetCategoryIdNum);
+
+  const categoryMap = new Map<string, E4Category>();
+  e4Categories.forEach((cat) => {
+    if (cat && cat.id) {
+      categoryMap.set(cat.id, cat);
+    }
+  });
+
+  const targetCategory = categoryMap.get(targetCategoryIdStr);
+
+  if (!targetCategory) {
+    console.warn(
+      `Target category ID ${targetCategoryIdStr} not found in category list.`,
+    );
+    return "";
+  }
+
+  const parentId = targetCategory.parentId;
+
+  if (parentId == null || targetCategory.id === "1") {
+    return "";
+  }
+
+  if (parentId === "1") {
+    const childSeoCrumbs: string[] = [];
+    categoryMap.forEach((cat) => {
+      if (cat.parentId === targetCategoryIdStr && cat.seoCrumb) {
+        childSeoCrumbs.push(cat.seoCrumb);
+      }
+    });
+    const filterString = childSeoCrumbs.join("|");
+    return filterString;
+  }
+
+  const filterString = targetCategory.seoCrumb ?? "";
+  if (!targetCategory.seoCrumb) {
+    console.warn(
+      `Target category ${targetCategoryIdStr} is missing seoCrumb, filter might not work as expected.`,
+    );
+  }
+  return filterString;
+};
+
+export const productListInputTransform = async (
+  input: SearchByCriteriaInput,
+) => {
+  const categoryFilter = await generateCategoryFilterString(
+    input.categoryId ?? "",
+  );
+
+  const grouped = input?.searchState?.refinement?.reduce(
+    (acc: Record<string, string[]>, ref: ProductRefinerValue) => {
+      const key = RECORD_ID_MAPPER.getAttributeId(ref?.RefinerRecordId ?? 0);
+      if (!key) return acc;
+
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(ref?.LeftValueBoundString ?? "");
+      return acc;
+    },
+    {} as Record<string, string[]>,
+  );
+
+  const filters = Object.entries(grouped).map(([key, values]) => ({
+    key,
+    value: (values as string[]).join(","),
+  }));
+
+  const sortDesc =
+    !!input?.searchState?.queryResultSettings.Sorting?.Columns?.[0]
+      ?.IsDescending;
+  let sortName =
+    input?.searchState?.queryResultSettings?.Sorting?.Columns?.[0]?.ColumnName?.toLowerCase();
+  // No relevance sort in e4 API.
+  sortName =
+    sortName === "relevance"
+      ? ""
+      : sortDesc
+        ? `${sortName}-hl`
+        : `${sortName}-lh`;
+
+  return {
+    categoryId: input?.categoryId ? String(input?.categoryId) : "1",
+    categoryFilter,
+    top: input?.searchState?.queryResultSettings?.Paging?.Top || 20,
+    skip: input?.searchState?.queryResultSettings?.Paging?.Skip || 0,
+    sort: sortName ? sortName : null,
+    sortDesc,
+    filters: filters && filters.length ? filters : [],
+    search: input?.searchState?.searchTerm,
+  };
+};
+
+export const refinersTransformValidate = (
+  rawFilters: Attribute[],
+): TransformedRefiner[] => {
+  if (!rawFilters || !Array.isArray(rawFilters)) {
+    console.warn(
+      "Invalid input received by refinersTransformValidate: must be an array.",
+      rawFilters,
+    );
+    return [];
+  }
+
+  const DATA_TYPE_VALUE_STRING = 5;
+  const REFINER_TYPE_VALUE_DISCRETE = 1;
+  const DISPLAY_TEMPLATE_VALUE_DEFAULT = 0;
+  const SOURCE_VALUE_ATTRIBUTE = 2;
+  const ODATA_TYPE_REFINER =
+    "#Microsoft.Dynamics.Commerce.Runtime.DataModel.ProductRefiner";
+  const ODATA_TYPE_REFINER_VALUE =
+    "#Microsoft.Dynamics.Commerce.Runtime.DataModel.ProductRefinerValue";
+  const DIMENSION_ATTRIBUTE_IDS = ["size", "color", "style"];
+
+  // Treat price filter as list filter (DisplayTemplateValue as 0) for now, until e4 API supports price bar filtering.
+  return rawFilters
+    .map((rawRefiner): TransformedRefiner | null => {
+      if (
+        !rawRefiner ||
+        typeof rawRefiner !== "object" ||
+        !rawRefiner.AttributeName ||
+        !Array.isArray(rawRefiner.value)
+      ) {
+        console.warn("Skipping invalid raw refiner object:", rawRefiner);
+        return null;
+      }
+
+      const transformedValues: TransformedRefinerValue[] = rawRefiner.value
+        .map((rawValue): TransformedRefinerValue | null => {
+          if (
+            !rawValue ||
+            typeof rawValue !== "object" ||
+            !rawValue.AttributeValue ||
+            typeof rawValue.Count !== "number"
+          ) {
+            console.warn(
+              "Skipping invalid raw refiner value object:",
+              rawValue,
+            );
+            return null;
+          }
+
+          RECORD_ID_MAPPER.add(
+            Number(rawValue?.id),
+            rawValue?.AttributeId ?? "",
+          );
+
+          return {
+            RefinerRecordId: Number(rawValue?.id),
+            DataTypeValue: DATA_TYPE_VALUE_STRING,
+            LeftValueBoundString: rawValue.AttributeValue,
+            RightValueBoundString: rawValue.AttributeValue,
+            UnitText: "",
+            RowNumber: 0,
+            Count: rawValue.Count,
+            LeftValueBoundLocalizedString: "",
+            RightValueBoundLocalizedString: "",
+            ExtensionProperties: [],
+            RefinerSourceValue: SOURCE_VALUE_ATTRIBUTE,
+            SwatchImageUrl: "",
+            SwatchColorHexCode:
+              rawValue?.AttributeId === "color" ? rawValue.AttributeValue : "",
+            "@odata.type": ODATA_TYPE_REFINER_VALUE,
+          };
+        })
+        .filter((value): value is TransformedRefinerValue => value !== null);
+
+      const isDimension = DIMENSION_ATTRIBUTE_IDS.includes(
+        rawRefiner.AttributeId?.toLowerCase() ?? "",
+      );
+
+      return {
+        RecordId: Number(rawRefiner?.id),
+        KeyName: rawRefiner?.displayName ?? "",
+        DataTypeValue: DATA_TYPE_VALUE_STRING,
+        RefinerTypeValue: REFINER_TYPE_VALUE_DISCRETE,
+        DisplayTemplateValue: DISPLAY_TEMPLATE_VALUE_DEFAULT,
+        ExtensionProperties: [],
+        SourceValue: SOURCE_VALUE_ATTRIBUTE,
+        Values: transformedValues,
+        IsDimension: isDimension,
+        "@odata.type": ODATA_TYPE_REFINER,
+      };
+    })
+    .filter((refiner): refiner is TransformedRefiner => refiner !== null);
+};
+
+/**
+ * Note: Try to use retail-server schema first, if it has too many
+ * required fields, create a custom schema with only frontend required fields
+ */
+
+/**
+ * Note: Try to use retail-server schema first, if it has too many
+ * required fields, create a custom schema with only frontend required fields
+ */
+
+/**
+ * Transforms the E4 AddToCart response to a Cart retail-proxy object
+ * Add parameters to transform model as needed
+ *
+ * @param data the E4 Cart object
+ * @returns the transformed cart object
+ */
+export const cartTransformValidate = (cart: E4Cart): Cart => {
+  if (!(cart && cart?.id)) throw new Error("Not a valid cart");
+  const transformedData = merge(cart, cartMap);
+  try {
+    extendedCartSchema.parse(transformedData);
+  } catch (e) {
+    console.warn("Cart data does not match retail-proxy schema", e);
+  }
+
+  return transformedData as Cart;
+};
+
+/**
+ * Transforms the E4 Product response to a Product retail-proxy object
+ * @param productData the E4 Product object
+ * @returns the transformed product object
+ */
+export const productTransformValidate = (
+  productData: Product,
+): ProductDetails => {
+  const translatedData = merge(
+    productData,
+    productDetailsMap,
+  ) as ProductDetails;
+  try {
+    productSchema.parse(translatedData);
+  } catch (e) {
+    console.warn("Product data does not match retail-proxy schema", e);
+  }
+  return translatedData;
+};
+
+export const productWithCategoryTransformValidate = (
+  productData: Product,
+): ProductSearchResult => {
+  const productTransform = merge(
+    productData,
+    productMap,
+  ) as ProductSearchResult;
+
+  // const productWithCategory = {
+  //   ...productTransform,
+  //   // Category: categoryTransformValidate([
+  //   //   productData?.category?.[0],
+  //   // ] as E4Category[]),
+  // } as unknown as ProductSearchResult;
+
+  // try {
+  //   productWCategorySchema.parse(productWithCategory);
+  // } catch (e) {
+  //   console.warn(
+  //     "Product data with category does not match retail-proxy schema",
+  //     e
+  //   );
+  //   throw e;
+  // }
+
+  return productTransform;
+};
+
+export const userTransformInput = (user: User): UserInput => {
+  let formattedUser = {};
+
+  if (user.FirstName && user.LastName) {
+    formattedUser = {
+      firstName: user?.FirstName,
+      lastName: user?.LastName,
+    };
+  }
+
+  if (user?.DefaultShippingAddressId) {
+    const shippingInfo = {
+      defaultShippingAddressId: user?.DefaultShippingAddressId,
+    };
+    formattedUser = { ...formattedUser, ...shippingInfo };
+  }
+
+  return formattedUser;
+};
+
+/**
+ * Transforms the e4 API session data to Session schema.
+ */
+export const sessionTransformValidate = (data: E4Session): Session => {
+  const formattedSession: Session = {
+    Id: data?.id,
+    User: {
+      AccountNumber: data?.user?.accountId ?? "",
+      FirstName: data?.user?.firstName ?? "",
+      LastName: data?.user?.lastName ?? "",
+      Email: data?.user?.email ?? "",
+      // Add other required fields with defaults if needed
+    },
+  };
+  return formattedSession;
+};
+
+/**
+ * Transforms the Address schema to e4 API address
+ */
+export const addressTransform = async (address: Address) => {
+  const countryId = await getCountryId(address?.ThreeLetterISORegionName ?? "");
+  const stateId = await getStateId(address?.State ?? "", countryId ?? "");
+
+  const formattedAddress: AddressInput = merge(address, addressReverseMap);
+  formattedAddress.firstName = "";
+  formattedAddress.lastName = "";
+  formattedAddress.address2 = "";
+  formattedAddress.stateId = stateId;
+  formattedAddress.countryId = countryId;
+  formattedAddress.addressTypeId = 1; // We only create and update shipping addresses.
+
+  return formattedAddress;
+};
+
+export const countriesTransformValidate = (countries: Country[]) => {
+  if (Array.isArray(countries) && countries.length) {
+    return countries.map((country) => merge(country, countriesMap));
+  }
+  return [];
+};
+
+export const countryTransformValidate = (country: Country) => {
+  if (country?.state && country?.state.length) {
+    return merge(country, countryMap);
+  }
+  return [];
+};
+
+const countriesCache = new Map<string, Country[]>();
+const countryCache = new Map<string, Country>();
+
+/**
+ * For d365 country id and value are 'USA' but for e4 it is '80175021088166' and 'USA'.
+ * So use countryId, to map the codes back to ids before API calls.
+ */
+export const getCountryId = async (code: string) => {
+  const cacheKey = "countries";
+  let countries: Country[] = [];
+
+  if (countriesCache.has(cacheKey)) {
+    countries = countriesCache.get(cacheKey) ?? countries;
+  } else {
+    const e4Api = await getGraphqlClient();
+    const { data } = await e4Api.e4CountryList();
+    countriesCache.set(cacheKey, data?.countries as Country[]);
+    countries = data?.countries as Country[];
+  }
+  const country = countries.find(
+    (c: { isoAlpha3Code: string }) => c?.isoAlpha3Code === code,
+  );
+
+  return country?.id;
+};
+
+const getStateId = async (stateCode: string, countryId: string) => {
+  const cacheKey = `states-${countryId}`;
+  let country: Country = {
+    id: "",
+    isoAlpha2Code: "",
+    isoAlpha3Code: "",
+    name: "",
+  };
+
+  if (countryCache.has(cacheKey)) {
+    country = countryCache.get(cacheKey) ?? country;
+  } else {
+    const e4Api = await getGraphqlClient();
+    const { data } = await e4Api.e4Country({ id: countryId });
+    countryCache.set(cacheKey, data?.country as Country);
+  }
+
+  const state = country?.state?.find((s) => s?.code === stateCode);
+
+  return state?.id;
+};
+
+export const deliveryOptionsTransformValidate = (options: Shipping[]) => {
+  if (Array.isArray(options) && options.length) {
+    return options.map((option) => merge(option, deliveryOptionsMap));
+  }
+  return [];
+};
+
+interface TransformedCategoryNode extends Category {
+  Slug: string;
+  Url: string;
+  NeutralizedName: string;
+  Children?: TransformedCategoryNode[];
+  ParentCategory?: number;
+}
+
+export const categoryTransformValidate = (
+  rawCategories: E4Category[],
+  rootParentId = 1,
+  urlPrefix = "e4",
+): CategoryHierarchy[] => {
+  function generateSlug(name: string): string {
+    if (!name) return "";
+    return name
+      .toLowerCase()
+      .replace(/\s+/g, "-")
+      .replace(/[^\w-]+/g, "")
+      .replace(/--+/g, "-")
+      .replace(/^-+/, "")
+      .replace(/-+$/, "");
+  }
+
+  function createTransformedNode(
+    rawCategory: E4Category,
+  ): TransformedCategoryNode | null {
+    let recordIdNum: number;
+    try {
+      recordIdNum = parseInt(String(rawCategory.id), 10);
+      if (isNaN(recordIdNum)) throw new Error("Invalid RecordId");
+    } catch (e) {
+      console.warn(`Skipping category due to invalid id:`, rawCategory);
+      return null;
+    }
+
+    const categoryName = rawCategory.name || "Unnamed Category";
+    const slug = generateSlug(categoryName);
+    let parentIdNum: number | undefined = undefined;
+    if (rawCategory.parentId != null) {
+      const parsedParentId = parseInt(String(rawCategory.parentId), 10);
+      if (!isNaN(parsedParentId)) parentIdNum = parsedParentId;
+      else
+        console.warn(
+          `Invalid parentId format for id ${recordIdNum}:`,
+          rawCategory.parentId,
+        );
+    }
+
+    const node: TransformedCategoryNode = {
+      RecordId: recordIdNum,
+      Name: categoryName,
+      ParentCategory: parentIdNum,
+      DisplayOrder: 0,
+      LocalizedDescription: categoryName,
+      Images: [
+        {
+          Uri: `Categories/${categoryName}.png`,
+          IsDefault: false,
+          IsSelfHosted: false,
+          Priority: 0,
+          IsAdditionalMedia: false,
+          MediaTypeValue: 0,
+          DisplayOrder: 0,
+          IsApplicableForChildEntities: false,
+          ExtensionProperties: [],
+        },
+      ],
+      NameTranslations: [
+        { Language: "en-us", Text: categoryName, ExtensionProperties: [] },
+      ],
+      ExtensionProperties: [],
+      NeutralizedName: categoryName,
+      Slug: slug,
+      Url: "",
+      Children: [],
+    };
+    return node;
+  }
+
+  function calculateUrls(
+    categoryNode: TransformedCategoryNode,
+    basePath: string,
+    prefix: string,
+  ): void {
+    const currentPath = basePath
+      ? `${basePath}/${categoryNode.Slug}`
+      : `${prefix}/${categoryNode.Slug}`;
+    categoryNode.Url = `${currentPath}/${categoryNode.RecordId}`;
+    // Check if Children exists before iterating
+    if (categoryNode?.Children && categoryNode?.Children?.length > 0) {
+      categoryNode.Children.forEach((child: TransformedCategoryNode) =>
+        calculateUrls(child, currentPath, prefix),
+      );
+    }
+  }
+
+  function removeEmptyChildren(node: TransformedCategoryNode): void {
+    if (node.Children) {
+      if (node.Children.length === 0) {
+        delete node.Children;
+      } else {
+        node.Children.forEach(removeEmptyChildren);
+      }
+    }
+  }
+
+  if (!rawCategories || !Array.isArray(rawCategories)) {
+    console.error(
+      "Invalid input received by categoryTransformValidate: must be an array.",
+      rawCategories,
+    );
+    return [];
+  }
+
+  const categoryMap = new Map<number, TransformedCategoryNode>();
+  const rootNodes: TransformedCategoryNode[] = [];
+
+  rawCategories.forEach((rawCat: E4Category) => {
+    const transformedNode = createTransformedNode(rawCat);
+    if (transformedNode)
+      categoryMap.set(transformedNode.RecordId, transformedNode);
+  });
+
+  categoryMap.forEach((node: TransformedCategoryNode) => {
+    const parentId = node.ParentCategory;
+    if (parentId === rootParentId) rootNodes.push(node);
+    else if (parentId !== undefined && categoryMap.has(parentId)) {
+      const parentNode = categoryMap.get(parentId);
+      if (parentNode) {
+        if (!parentNode.Children) {
+          parentNode.Children = [];
+        }
+        parentNode.Children.push(node);
+        parentNode.Children.sort(
+          (a, b) =>
+            (a.DisplayOrder ?? 0) - (b.DisplayOrder ?? 0) ||
+            (a.Name ?? "").localeCompare(b.Name ?? ""),
+        );
+      }
+    }
+  });
+
+  rootNodes.forEach((rootNode: TransformedCategoryNode) =>
+    calculateUrls(rootNode, "", urlPrefix),
+  );
+  rootNodes.sort(
+    (a, b) =>
+      (a.DisplayOrder ?? 0) - (b.DisplayOrder ?? 0) ||
+      (a.Name ?? "").localeCompare(b.Name ?? ""),
+  );
+
+  rootNodes.forEach(removeEmptyChildren);
+
+  return rootNodes as CategoryHierarchy[];
+};