@evenicanpm/storefront-core 1.0.0-alpha

package/src/api-manager/datasources/e4/e4-product.datasource.ts

@@ -0,0 +1,157 @@
+import * as productSchema from "@/api-manager/schemas/product.schema";
+import {
+  ProductSearchResult,
+  SimpleProduct,
+} from "@msdyn365-commerce/retail-proxy";
+import {
+  Attribute,
+  Product,
+  ProductLookupType,
+  CategoriesQuery,
+} from "./graphqlRequestSdk";
+import * as translator from "./e4.translator";
+import getGraphqlClient from "../../lib/get-graphql-client";
+import { ProductApi } from "../../types/Datasource";
+import { generateCategoryFilterString } from "./e4.translator";
+
+const product: ProductApi = {
+  async getProductById(
+    input: productSchema.GetProductByIdInput,
+  ): Promise<productSchema.ProductDetails> {
+    const e4Api = await getGraphqlClient();
+
+    // fetch data
+    const { data, errors } = await e4Api.e4ProductReadLG({
+      id: String(input.id),
+      productLookupType: ProductLookupType.Id,
+    });
+
+    if (errors) {
+      throw new Error("Error getting product");
+    }
+
+    const transformedData = translator.productTransformValidate(
+      data.product as Product,
+    );
+    return transformedData;
+  },
+
+  async getProductByIds(
+    input: productSchema.GetProductByIdsInput,
+  ): Promise<SimpleProduct[]> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.GetProductsByIds({
+      ids: input.id.map(String),
+    });
+
+    if (errors) {
+      throw new Error("Error getting products");
+    }
+    return (
+      data?.getProductsByIds?.map((productData) =>
+        translator.productTransformValidate(productData as Product),
+      ) || []
+    );
+  },
+
+  async searchProducts(
+    input: productSchema.searchProductsInput,
+  ): Promise<ProductSearchResult[]> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.productTypeaheadSearchByCategory({
+      input: {
+        search: input.searchText,
+        categoryId: await generateCategoryFilterString(input.category ?? 0),
+        top: 10,
+        skip: 0,
+      },
+    });
+    if (errors) {
+      throw new Error("Error getting products");
+    }
+
+    const products = data?.productsTypeAhead
+      ?.map((product) => {
+        const transformedProduct =
+          translator.productWithCategoryTransformValidate(product as Product);
+
+        // Ensure Price is always a number (not undefined)
+        if (transformedProduct) {
+          return {
+            ...transformedProduct,
+            // Provide default value of 0 if Price is undefined
+            Price: transformedProduct.Price ?? 0,
+          };
+        }
+        return null;
+      })
+      .filter(Boolean) as ProductSearchResult[];
+    return products as ProductSearchResult[];
+  },
+
+  async getProductsList(
+    input: productSchema.SearchByCriteriaInput,
+  ): Promise<productSchema.SearchByCriteriaResponse> {
+    const e4Api = await getGraphqlClient();
+
+    const { data, errors } = await e4Api.e4ProductListMD(
+      await translator.productListInputTransform(input),
+    );
+    if (errors) {
+      throw new Error("Error getting products");
+    }
+
+    const rawProducts: Product[] = (data.products?.products || []).filter(
+      (prod): prod is Product => prod !== null,
+    );
+    const rawFilters: Attribute[] = (data.products?.filters || []).filter(
+      (filter): filter is Attribute => filter !== null,
+    );
+    const transformedProducts = rawProducts.map((prod) =>
+      translator.productTransformValidate(prod),
+    );
+    const transformedRefiners =
+      translator.refinersTransformValidate(rawFilters);
+
+    return {
+      products: transformedProducts,
+      refiners: transformedRefiners,
+      count: data.products?.recordCount ?? 0,
+    };
+  },
+
+  async getCategoryList(): Promise<CategoriesQuery> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.categories();
+    if (errors) {
+      throw new Error("Error reading categories in getCategoryList");
+    }
+    return data;
+  },
+
+  // Full BOPIS implementation
+  async getInventory(input) {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.e4ProductReadLG({
+      id: String(input.searchCriteria.productIds[0]),
+      productLookupType: ProductLookupType.Id,
+    });
+
+    if (errors) {
+      throw new Error("Error retrieving e4 product inventory in getInventory");
+    }
+    // adding dummy properties to data just to satisfy front end BOPIS components
+    // src/app/[locale]/(default)/product/[name]/[id]/product-intro/product-intro.tsx:94
+    return {
+      TotalAvailable: data.product?.Available || 0,
+      AggregatedProductInventoryAvailabilities: ["IN STOCK"],
+    };
+  },
+  getRelatedProducts: function (
+    input: productSchema.GetRelatedProductsInput,
+  ): Promise<ProductSearchResult[]> {
+    throw new Error(`Function not implemented.${input}`);
+  },
+};
+
+export default product;

package/src/api-manager/datasources/e4/e4-session.datasource.ts

@@ -0,0 +1,43 @@
+import getGraphqlClient from "../../lib/get-graphql-client";
+import {
+  Session,
+  SessionInitInput,
+} from "@/api-manager/schemas/session.schema";
+import * as translator from "./e4.translator";
+
+const session = {
+  async sessionInit(input: SessionInitInput): Promise<Session> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.customerInitSession({
+      input: {
+        authToken: input.accessToken,
+        userName: input.email,
+      },
+    });
+
+    if (errors) {
+      throw new Error("Error adding user to e4 session");
+    }
+
+    return translator.sessionTransformValidate(
+      data?.customerInitSession ?? { id: "" },
+    );
+  },
+  async sessionLogout(): Promise<boolean> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.e4CustomerLogoutSession();
+
+    if (errors) {
+      throw new Error("Error e4 session logout");
+    }
+
+    return !!data?.customerLogout?.success;
+  },
+  async getSession(): Promise<Session> {
+    if (true) {
+      throw new Error("Error reading e4 session");
+    }
+  },
+};
+
+export default session;

package/src/api-manager/datasources/e4/e4-user.datasource.ts

@@ -0,0 +1,118 @@
+import getGraphqlClient from "../../lib/get-graphql-client";
+import { User, UserCounts } from "@/api-manager/schemas/user.schema";
+import * as translator from "./e4.translator";
+import { CreateWishListInput, WishList } from "./graphqlRequestSdk";
+import { userMap } from "./e4.remaps";
+import { merge } from "object-mapper";
+
+const user = {
+  async updateUser(user: User): Promise<User> {
+    const e4Api = await getGraphqlClient(true);
+
+    const userInput = translator.userTransformInput(user);
+
+    const { data, errors } = await e4Api.e4UserUpdateMD({
+      user: userInput,
+    });
+
+    if (errors) {
+      throw new Error("Error updating e4 user");
+    }
+
+    return merge(data?.updateUser ?? {}, userMap) as User;
+  },
+  async getUser(): Promise<User> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.e4UserReadMD();
+
+    if (errors) {
+      throw new Error("Error reading e4 user");
+    }
+
+    return merge(data?.me ?? {}, userMap) as User;
+  },
+  async getUserCounts(userId: string): Promise<UserCounts> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.e4UserCounts({ id: userId });
+
+    if (errors) {
+      throw new Error("Error getting user counts");
+    }
+
+    return {
+      orderCount: data?.getOrderCount ?? 0,
+      addressCount: data?.getAddressCount ?? 0,
+    };
+  },
+  async getWishlists(): Promise<WishList[]> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.e4WishListListSM();
+
+    if (errors) {
+      throw new Error("Error getting wishlists");
+    }
+
+    return data?.wishlistList?.nodes ?? [];
+  },
+
+  async getWishlistDetails(id: string): Promise<WishList> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.e4WishListReadMD({ id });
+
+    if (errors) {
+      throw new Error("Error getting wishlist details");
+    }
+
+    const wishList = data?.wishList;
+
+    if (!wishList) {
+      throw new Error("No wishlist found");
+    }
+
+    return {
+      ...wishList,
+      products: {
+        edges: [],
+        ...wishList.products,
+      },
+    } as unknown as WishList;
+  },
+  async createWishlist(wishlist: CreateWishListInput): Promise<WishList> {
+    if (!wishlist.name) {
+      throw new Error("Wishlist name is required");
+    }
+
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.upsertWishlist({ wishlist });
+
+    if (errors) {
+      throw new Error("Error creating wishlist");
+    }
+
+    const wishList = data?.upsertWishlist;
+
+    if (!wishList) {
+      throw new Error("No wishlist found");
+    }
+
+    return wishList as WishList;
+  },
+  async deleteWishlist(id: string): Promise<string> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.deleteWishList({ id });
+
+    if (errors) {
+      throw new Error("Error creating wishlist");
+    }
+
+    return data?.deleteWishList ?? "";
+  },
+};
+
+export default user;

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

@@ -0,0 +1,55 @@
+import { PrimaryDatasource } from "../../types/Datasource";
+import getGraphqlClient from "../../lib/get-graphql-client";
+import { Category as E4Category } from "./graphqlRequestSdk";
+import * as translator from "./e4.translator";
+// Data source files
+import user from "./e4-user.datasource";
+import session from "./e4-session.datasource";
+import { cart } from "./e4-cart.datasource";
+import order from "./e4-order.datasource";
+import address from "./e4-address.datasource";
+import { CategoryHierarchy } from "../../lib/category-helpers";
+import product from "./e4-product.datasource";
+import organization from "./e4-organization.datasource";
+
+const E4Datasource: PrimaryDatasource = {
+  name: "e4",
+  user,
+  session,
+  cart,
+  order,
+  address,
+  product,
+  organization,
+  categories: {
+    async getCategories(): Promise<CategoryHierarchy[]> {
+      const e4Api = await getGraphqlClient();
+      const { data: rawApiResult, errors } = await e4Api.categories();
+
+      if (errors) {
+        console.error(
+          "GraphQL errors reading categories (in categories.getCategories):",
+          errors,
+        );
+        throw new Error("Error getting categories");
+      }
+
+      const rawCategoryArray = rawApiResult?.categories?.category;
+
+      if (!Array.isArray(rawCategoryArray)) {
+        console.warn(
+          "Categories data at expected path not found or not an array in categories.getCategories:",
+          rawApiResult,
+        );
+        return [];
+      }
+
+      const transformedHierarchicalData = translator.categoryTransformValidate(
+        rawApiResult?.categories?.category as E4Category[],
+      );
+      return transformedHierarchicalData;
+    },
+  },
+};
+
+export default E4Datasource;

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

@@ -0,0 +1,331 @@
+/**
+ * Maps E4 API responses to the D365 data structure.
+ *
+ * This file uses the `object-mapper` library to transform
+ * API responses into a format compatible with D365.
+ *
+ * https://github.com/wankdanker/node-object-mapper
+ *
+ */
+
+import {
+  Address,
+  Product as DynProduct,
+} from "@msdyn365-commerce/retail-proxy";
+import { merge } from "object-mapper";
+import {
+  Image,
+  Product,
+  Address as E4Address,
+  CartLine,
+  OrderLine,
+  SelectedDimension,
+  Me,
+} from "./graphqlRequestSdk";
+import unwrapE4Variants from "./utils/unwrap-e4-variants";
+
+/* PRODUCT REMAPS */
+export const dimensionMap = {
+  AttributeId: "DimensionTypeValue",
+  Value: "DimensionValue.Value",
+  ValueId: "DimensionValue.RecordId",
+  _: {
+    key: "TotalAvailableInventoryLevelCode",
+    default: "AVAIL",
+  },
+};
+
+export const productMap = {
+  sku: "ItemId",
+  name: "Name",
+  MasterProductId: "MasterProductId",
+  price: [
+    { key: "Price", default: 0 },
+    { key: "BasePrice", default: 0 },
+    { key: "AdjustedPrice", default: 0 },
+  ],
+  id: [
+    {
+      key: "RecordId",
+      transform: (id: string) => {
+        if (id !== null) return parseInt(id);
+      },
+    },
+  ],
+  img: {
+    key: "PrimaryImageUrl",
+    transform: (img: Image[]) => {
+      if (Array.isArray(img) && img.length > 0) {
+        return img[0].cdnURL ?? null;
+      }
+      return null;
+    },
+  },
+};
+
+export const productDetailsMap = {
+  ...productMap,
+  MasterProductId: "MasterProductId",
+  "img[].cdnURL": "Images[]",
+  description: "Description",
+  "Dimensions[].AttributeId": "Dimensions[].DimensionTypeValue",
+  Variants: {
+    key: "DimensionValues",
+    transform: unwrapE4Variants,
+  },
+  "attributes[].Name": "Attributes[].Name",
+  "attributes[].Value": "Attributes[].TextValue",
+};
+
+/* CART REMAPS */
+export const cartLineMap = {
+  "[].product": {
+    key: "[].Product?",
+    transform: (product: Product) => {
+      // If cart is empty, prevents CartLines[] from having entries
+      if (!product) return;
+
+      // For some reason transform is run multiple times. This prevents merge from running multiple times and overwriting translation.
+      const translated = merge(product, productMap) as DynProduct & {
+        ProductTypeValue?: number;
+      };
+      if (!translated.RecordId) return product;
+      translated.ProductTypeValue = 4; // default for now. Type = Standalone
+      return translated;
+    },
+  },
+  "[].id": "[].LineId",
+  "[].product.id": {
+    key: "[].ProductId",
+    transform: (id: string) => {
+      if (id !== null) return parseInt(id);
+    },
+  },
+  "[].product.code": "[].ItemId",
+  "[].product.name": "[].Product.Name",
+  "[].quantity": "[].Quantity",
+  "[].price": [
+    { key: "[].Price", default: 0 },
+    { key: "[].Product.Price", default: 0 },
+    { key: "[].Product.BasePrice", default: 0 },
+    { key: "[].Product.AdjustedPrice", default: 0 },
+  ],
+  "[].amount": [{ key: "[].TotalAmount" }, { key: "[].NetPrice" }],
+  "[].uom.name": {
+    key: "[].UnitOfMeasureSymbol",
+    transform: (name: string) => {
+      if (name !== null) {
+        if (name === "Each") return "ea";
+        return name;
+      }
+    },
+  },
+  "[].product.productType": {
+    key: "[].Product.ProductTypeValue",
+    default: 4,
+  },
+};
+
+export const addressMap = {
+  "[].id": [
+    { key: "[].Id" },
+    {
+      key: "[].RecordId",
+      transform: (id: string) => {
+        if (id !== null) return parseInt(id);
+      },
+    },
+  ],
+  "[].name": "[].Name",
+  "[].isPrimary": "[].IsPrimary",
+  "[].addressType.id": {
+    key: "[].AddressTypeValue",
+    transform: (id: string) => {
+      if (id !== null) return parseInt(id);
+    },
+  },
+  "[].address1": "[].Street",
+  "[].city": "[].City",
+  "[].stateName": "[].State",
+  "[].countryName": "[].ThreeLetterISORegionName",
+  "[].postalCode": "[].ZipCode",
+  "[].phoneNumber": "[].Phone",
+  "[].address2": {
+    key: "[].FullAddress",
+    transform: (_val: string, _src: E4Address[], dest: Address) => {
+      return `${dest?.Street}, ${dest?.City} ${dest?.State} ${dest?.ZipCode}, ${dest?.ThreeLetterISORegionName}`;
+    },
+  },
+};
+
+export const addressReverseMap = {
+  Name: "name",
+  Street: "address1",
+  City: "city",
+  ZipCode: "postalCode",
+  Phone: "phoneNumber",
+  Id: "id",
+};
+
+export const userMap = {
+  id: {
+    key: "RecordId",
+    transform: (id: string) => {
+      return Number(id);
+    },
+  },
+  code: {
+    // we don't need AccountNumber in e4 storefront,
+    // if we need it bring account data and map accountId here.
+    key: "AccountNumber",
+    transform: () => {
+      return "";
+    },
+  },
+  firstName: "FirstName",
+  lastName: "LastName",
+  email: "Email",
+  defaultShippingAddressId: "DefaultShippingAddressId",
+  addresses: {
+    key: "Addresses",
+    transform: (addresses: E4Address[], source: Me) => {
+      if (!(addresses && addresses?.length)) return [];
+      const mapped = merge(addresses || [], addressMap) as Address[];
+      return mapped.map((address: Address) => ({
+        ...address,
+        IsPrimary:
+          address?.IsPrimary ||
+          address?.Id === source?.defaultShippingAddressId,
+      }));
+    },
+  },
+};
+
+export const countriesMap = {
+  isoAlpha3Code: "CountryRegionId",
+  isoAlpha2Code: "ISOCode",
+  name: "ShortName",
+};
+
+export const countryMap = {
+  "state[].code": "[].StateId",
+  "state[].name": "[].StateName",
+  isoAlpha3Code: "[].CountryRegionId",
+};
+
+export const deliveryOptionsMap = {
+  id: ["Code", "RecordId"],
+  name: "Description",
+  total: "TotalChargeAmount",
+};
+
+export const cartMap = {
+  id: "Id",
+  itemCount: "TotalItems",
+
+  lines: {
+    key: "CartLines",
+    transform: (lines: CartLine[]) => {
+      if (lines.length === 0) return [];
+      return merge(lines, cartLineMap);
+    },
+  },
+
+  subtotal: "SubtotalAmountWithoutTax",
+  freightTotal: "ShippingChargeAmount",
+  taxTotal: "TaxAmount",
+  total: "TotalAmount",
+  email: "ReceiptEmail",
+
+  addresses: {
+    key: "ShippingAddress",
+    transform: (addresses: E4Address[]) => {
+      if (addresses.length === 0) return undefined;
+      const translated = merge(addresses, addressMap) as Address[];
+      return translated[addresses.length - 1];
+    },
+  },
+};
+
+const STATUSES = ["Open", "Processing", "Complete", "On Hold", "Cancelled"];
+
+export const orderMap = {
+  id: "Id",
+  orderNumber: "ChannelReferenceId",
+  orderStatus: {
+    key: "StatusValue",
+    transform: (orderStatus: string) => {
+      return STATUSES.indexOf(orderStatus) + 1;
+    },
+  },
+  orderDate: "TransactionDate",
+  freightTotal: "ShippingChargeAmount",
+  promotionTotal: "DiscountAmount",
+  subTotal: "SubtotalAmount",
+  taxTotal: "TaxAmount",
+  itemCount: "NumberOfItems",
+  total: "TotalAmount",
+};
+
+const salesLinesProduct = {
+  productId: "RecordId",
+  productCode: "ItemId",
+  productName: "Name",
+  amount: "TotalAmount",
+  img: {
+    key: "PrimaryImageUrl",
+    transform: (img: Image[]) => {
+      if (Array.isArray(img) && img.length > 0) {
+        return img[0].cdnURL ?? null;
+      }
+      return null;
+    },
+  },
+  selectedDimensions: {
+    key: "Dimensions",
+    transform: (dimensions: SelectedDimension[]) => {
+      if (!(dimensions && dimensions.length)) return [];
+
+      const typeMap: Record<string, number> = {
+        Color: 1,
+        Size: 3,
+        // extend as needed
+        // map to import { ProductDimensionType } from "@msdyn365-commerce/retail-proxy";
+      };
+
+      return dimensions.map((d) => ({
+        DimensionTypeValue: typeMap[d.name ?? ""] ?? 0,
+        DimensionValue: {
+          RecordId: Number(d.id),
+          Value: d.value,
+          DimensionId: d.name,
+        },
+      }));
+    },
+  },
+};
+
+export const orderDetailsMap = {
+  ...orderMap,
+  lines: {
+    key: "SalesLines",
+    transform: (lines: OrderLine[]) => {
+      if (!(lines && lines.length)) return [];
+      return lines.map((line) => {
+        return {
+          Product: merge(line, salesLinesProduct),
+          Price: line?.price,
+          Quantity: line?.quantity,
+        };
+      });
+    },
+  },
+  addresses: {
+    key: "ShippingAddress",
+    transform: (addresses: E4Address[]) => {
+      if (addresses.length === 0) return undefined;
+      const translated = merge(addresses, addressMap) as Address[];
+      return translated[addresses.length - 1];
+    },
+  },
+};