@evenicanpm/storefront-core 1.0.0-alpha

package/src/api-manager/datasources/d365/test-context.ts

@@ -0,0 +1,30 @@
+import { IQueryResultSettings } from "@msdyn365-commerce/retail-proxy";
+
+const defaultQueryResultSettings: IQueryResultSettings = {
+  Paging: {
+    Top: 2,
+    Skip: 0,
+  },
+  Sorting: { Columns: [{ ColumnName: "Name", IsDescending: true }] },
+  count: true,
+};
+const context = {
+  requestContext: {
+    locale: "en-US",
+    apiSettings: {
+      baseUrl: "https://scui1e8d9zn85030208-rs.su.retail.dynamics.com/",
+      channelId: 68719478279,
+      oun: "128",
+      catalogId: 0,
+      baseImageUrl: "",
+    },
+    user: {
+      isAuthenticated: false,
+      token: "",
+    },
+    operationId: "1",
+  },
+  queryResultSettings: defaultQueryResultSettings,
+};
+
+export { context };

package/src/api-manager/datasources/d365/utils/create-search-criteria.ts

@@ -0,0 +1,17 @@
+import { ProductDimensionAvailabilitySearchCriteria } from "@msdyn365-commerce/retail-proxy";
+/**
+ * Helper: Create search criteria for product dimension availability.
+ * @param dimensionTypeValue
+ * @returns
+ */
+export const createDimSearchCriteria = (
+  dimensionTypeValue: number,
+): ProductDimensionAvailabilitySearchCriteria => {
+  return {
+    RequestedDimensionTypeValue: dimensionTypeValue,
+    MatchingDimensionValues: [],
+    DefaultWarehouseOnly: true,
+    FilterByChannelFulfillmentGroup: true,
+    CatalogId: 0,
+  };
+};

package/src/api-manager/datasources/d365/utils/decode-jwt.ts

@@ -0,0 +1,11 @@
+"use server";
+import { decode } from "next-auth/jwt";
+import { getConfig } from "@config";
+
+export async function decodeToken(token: string) {
+  const secret = getConfig().NEXTAUTH_SECRET;
+  if (!secret) {
+    throw new Error("Environment variable NEXTAUTH_SECRET is not set.");
+  }
+  return decode({ token: token, secret });
+}

package/src/api-manager/datasources/d365/utils/get-context-cookie.ts

@@ -0,0 +1,37 @@
+"use server";
+import { manuallyRetrieveSessionCookie } from "@/auth/next-auth-cookie-manager";
+import { ICallerContext } from "@msdyn365-commerce/retail-proxy";
+import { getLocale } from "next-intl/server";
+import { cookies } from "next/headers";
+
+/**
+ * Retrieves the D365 context from the "D365Context" cookie, enriches it with the current session token,
+ * locale, and a new operation ID, and returns it as an `ICallerContext` object.
+ *
+ * @returns {Promise<ICallerContext>} A promise that resolves to the enriched D365 caller context.
+ * @throws {Error} If the "D365Context" cookie is not found.
+ *
+ * @remarks
+ * - The function fetches the D365 context from cookies, parses it, and updates the request context with:
+ *   - A new `operationId` (UUID).
+ *   - The current user's authentication status and access token.
+ *   - The current locale.
+ * - Relies on `manuallyRetrieveSessionCookie` and `getLocale` for session and locale information.
+ */
+export async function getContextFromCookie(): Promise<ICallerContext> {
+  const cookieStore = await cookies();
+  const d365Context = cookieStore.get("D365Context");
+  const token = await manuallyRetrieveSessionCookie();
+  const locale = await getLocale();
+  if (d365Context) {
+    const context = JSON.parse(d365Context.value) as ICallerContext;
+    context.requestContext.operationId = crypto.randomUUID();
+    context.requestContext.user = {
+      isAuthenticated: !!token?.accessToken,
+      token: token?.accessToken ?? "",
+    };
+    context.requestContext.locale = locale;
+    return context;
+  }
+  throw new Error("D365Context cookie not found");
+}

package/src/api-manager/datasources/d365/utils/parse-object.ts

@@ -0,0 +1,9 @@
+const parseObject = async <TClass>(data: TClass): Promise<TClass> => {
+  try {
+    return JSON.parse(JSON.stringify(await data)) as TClass;
+  } catch {
+    return {} as TClass;
+  }
+};
+
+export default parseObject;

package/src/api-manager/datasources/d365/utils/product-images-utils.ts

@@ -0,0 +1,43 @@
+import { SimpleProduct } from "@msdyn365-commerce/retail-proxy";
+
+const testImageUrl = (url: string) => {
+  return new Promise<[string, boolean]>((resolve) => {
+    fetch(url, { method: "HEAD" })
+      .then((response) =>
+        response
+          .blob()
+          .then((buff) => resolve([url, buff.type.startsWith("image/")])),
+      )
+      .catch(() => resolve([url, false]));
+  });
+};
+
+export const testMedia = async (media: string[]) => {
+  const promises = media.map((m) => testImageUrl(m));
+  const validUrls = await Promise.all(promises).then((tuple) =>
+    tuple.filter((tp) => tp[1]).map((tp) => tp[0]),
+  );
+  return validUrls;
+};
+
+/**
+ * validateAndSetMediaUrls - Validates and sets the media urls for the product
+ * @returns
+ */
+export const validateAndSetMediaUrls = async (
+  productData: SimpleProduct,
+  baseUrl: string,
+) => {
+  const product = productData;
+  const primaryImageUrl = product?.PrimaryImageUrl;
+  if (!primaryImageUrl) {
+    return;
+  }
+  const urls = [];
+  for (let index = 1; index < 6; index++) {
+    const nextUrl = baseUrl + primaryImageUrl.replace("001", `00${index}`);
+    urls.push(nextUrl);
+  }
+  const validUrls = await testMedia(urls);
+  return validUrls;
+};

package/src/api-manager/datasources/d365/utils/product-inventory-utils.ts

@@ -0,0 +1,37 @@
+import {
+  InventoryAvailabilitySearchCriteria,
+  SearchArea,
+} from "@msdyn365-commerce/retail-proxy";
+
+export enum DeliveryMode {
+  allWareHouses = 0,
+  shipping = 1,
+  pickup = 2,
+}
+
+const createInventoryAvailabilitySearchCriteria = (
+  productIds: number[],
+  isDefaultWarehouse: boolean,
+  filterbyChannelFulfillmentGroup: boolean,
+  serachArea: SearchArea,
+  defaultDeliveryMode: DeliveryMode,
+) => {
+  const salesUnitType = 2; // Sales unit type is always 2 for product inventory
+  const deliveryMode = defaultDeliveryMode
+    ? defaultDeliveryMode
+    : DeliveryMode.shipping;
+
+  const inventoryAvailabilitySearchCriteria: InventoryAvailabilitySearchCriteria =
+    {
+      ProductIds: productIds,
+      QuantityUnitTypeValue: salesUnitType,
+      SearchArea: serachArea,
+      FilterByChannelFulfillmentGroup: filterbyChannelFulfillmentGroup,
+      DefaultWarehouseOnly: isDefaultWarehouse,
+      DeliveryModeTypeFilterValue: deliveryMode,
+    };
+
+  return inventoryAvailabilitySearchCriteria;
+};
+
+export { createInventoryAvailabilitySearchCriteria };

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

@@ -0,0 +1,107 @@
+import getGraphqlClient from "../../lib/get-graphql-client";
+import {
+  Address,
+  GetDeliveryOptionsInput,
+  GetStatesInput,
+} from "@/api-manager/schemas/address.schema";
+import {
+  CountryRegionInfo,
+  DeliveryOption,
+  StateProvinceInfo,
+} from "@msdyn365-commerce/retail-proxy";
+import { Shipping } from "./graphqlRequestSdk";
+import * as translator from "./e4.translator";
+import { addressMap } from "./e4.remaps";
+import { merge } from "object-mapper";
+
+const address = {
+  async getCountries(): Promise<CountryRegionInfo[]> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.e4CountryList();
+    if (errors) {
+      throw new Error("Error getting countries");
+    }
+
+    return translator.countriesTransformValidate(data?.countries ?? []);
+  },
+  async getStates(input: GetStatesInput): Promise<StateProvinceInfo[]> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.e4Country({
+      id: (await translator.getCountryId(input?.countryId || "")) ?? "",
+    });
+    if (errors) {
+      throw new Error("Error getting states");
+    }
+
+    const countryData = data?.country ?? {
+      id: "",
+      name: "",
+      isoAlpha2Code: "",
+      isoAlpha3Code: "",
+      state: [],
+    };
+    const result = translator.countryTransformValidate(countryData);
+    return Array.isArray(result) ? result : [];
+  },
+  async getDeliveryOptions(
+    input: GetDeliveryOptionsInput,
+  ): Promise<DeliveryOption[]> {
+    const e4Api = await getGraphqlClient();
+
+    const { data, errors } = await e4Api.shippingbyCarrier({
+      id: input?.shippingAddress?.ThreeLetterISORegionName ?? "",
+    });
+
+    if (errors) {
+      throw new Error("Error getting shipping methods");
+    }
+
+    return translator.deliveryOptionsTransformValidate(
+      (data?.shippingbyCarrier as Shipping[]) ?? [],
+    ) as DeliveryOption[];
+  },
+  async createAddress(address: Address): Promise<Address> {
+    const e4Api = await getGraphqlClient(true);
+    const e4Address = await translator.addressTransform(address);
+    const { data, errors } = await e4Api.e4AddressCreate({
+      address: e4Address,
+    });
+    if (errors) {
+      throw new Error("Error creating address");
+    }
+
+    return (
+      merge(
+        [data?.createAddress],
+        addressMap as unknown as Address[],
+      ) as Address[]
+    )[0];
+  },
+  async updateAddress(address: Address): Promise<Address> {
+    const e4Api = await getGraphqlClient(true);
+    const e4Address = await translator.addressTransform(address);
+    const { data, errors } = await e4Api.e4AddressUpdate({
+      address: e4Address,
+    });
+    if (errors) {
+      throw new Error("Error updating address");
+    }
+
+    return (
+      merge(
+        [data?.updateAddress],
+        addressMap as unknown as Address[],
+      ) as Address[]
+    )[0];
+  },
+  async deleteAddress(addressId: string): Promise<string> {
+    const e4Api = await getGraphqlClient(true);
+    const { data, errors } = await e4Api.e4AddressDelete({ id: addressId });
+    if (errors) {
+      throw new Error("Error deleting address");
+    }
+    return data?.deleteAddress ?? "";
+  },
+};
+
+export default address;

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

@@ -0,0 +1,248 @@
+import getGraphqlClient from "../../lib/get-graphql-client";
+import * as cartSchema from "../../schemas/cart.schema";
+import { Cart } from "../../schemas/cart.schema";
+import * as translator from "./e4.translator";
+
+import {
+  CardPaymentAcceptPoint,
+  CardPaymentAcceptResult,
+  LineDeliverySpecification,
+} from "@msdyn365-commerce/retail-proxy";
+import { CartApi } from "../../types/Datasource";
+import { Cart as E4Cart } from "./graphqlRequestSdk";
+import { SalesOrder } from "@/api-manager/schemas/order.schema";
+
+const cart: CartApi = {
+  //For this data source, initCart does the same thing as getCart
+  async initCart(): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { data, errors } = await e4Api.e4CartReadMD();
+
+    if (errors) {
+      throw new Error("Error reading cart");
+    }
+
+    const transformedData = translator.cartTransformValidate(
+      data?.cart as E4Cart,
+    );
+    return transformedData;
+  },
+
+  async addToCart(input: cartSchema.AddToCartInput): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { cartLine } = input;
+
+    const { data, errors } = await e4Api.e4AddToCartMD({
+      productId:
+        cartLine[0].ProductId?.toString() ||
+        cartLine[0].Product?.RecordId.toString() ||
+        "",
+      quantity: cartLine[0].Quantity,
+    });
+
+    if (errors) {
+      throw new Error("Error adding to cart");
+    }
+
+    const transformedData = translator.cartTransformValidate(
+      data?.addToCart?.cart as E4Cart,
+    );
+    return transformedData;
+  },
+
+  async updateCart(input: cartSchema.UpdateCartInput): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { cart } = input;
+
+    if (cart.ReceiptEmail) {
+      const setEmail = await e4Api.e4OrderEmailSet({
+        email: cart.ReceiptEmail,
+      });
+
+      if (setEmail.errors) {
+        throw new Error(
+          `Error updating cart - set order email unsuccessful. ${setEmail.errors}`,
+        );
+      }
+    }
+
+    if (cart.ShippingAddress) {
+      const address = cart.ShippingAddress;
+      const createAddress = await e4Api.e4CreateCartAddress({
+        address: await translator.addressTransform(address),
+      });
+
+      if (createAddress.errors) {
+        throw new Error(
+          `Error updating cart - create address unsuccessful. ${createAddress.errors}`,
+        );
+      }
+    }
+
+    const { data, errors } = await e4Api.e4CartReadMD();
+
+    if (errors) {
+      throw new Error("Error getting cart information");
+    }
+
+    const transformedData = translator.cartTransformValidate(
+      data?.cart as E4Cart,
+    );
+    return transformedData;
+  },
+
+  async updateCartLines(input: cartSchema.UpdateCartLineInput): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { cartLine } = input;
+    let cart;
+
+    for (const cl of cartLine) {
+      const { data, errors } = await e4Api.e4UpdateCartLineMD({
+        input: {
+          productId:
+            cl.ProductId?.toString() || cl.Product?.RecordId.toString() || "",
+          quantity: cl.Quantity,
+          unitOfMeasureId: "-1", // Set default value, UOM will be picked from product DB.
+        },
+      });
+
+      if (errors) {
+        throw new Error("Error updating cart lines");
+      }
+
+      cart = data.updateCartLine;
+    }
+
+    const transformedData = translator.cartTransformValidate(
+      cart?.cart as E4Cart,
+    );
+    return transformedData;
+  },
+
+  async deleteCartLine(input: cartSchema.DeleteCartLineInput): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { cartLine } = input;
+
+    const { data, errors } = await e4Api.e4DeleteCartLineMD({
+      input: {
+        productId:
+          cartLine[0].ProductId?.toString() ||
+          cartLine[0].Product?.RecordId.toString() ||
+          "",
+      },
+    });
+
+    if (errors) {
+      throw new Error("Error updating cart");
+    }
+
+    const transformedData = translator.cartTransformValidate(
+      data?.deleteCartLine?.cart as E4Cart,
+    );
+    return transformedData;
+  },
+
+  async getCart(): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { data, errors } = await e4Api.e4CartReadMD();
+
+    if (errors) {
+      throw new Error("Error reading cart");
+    }
+
+    const transformedData = translator.cartTransformValidate(
+      data?.cart as E4Cart,
+    );
+    return transformedData;
+  },
+
+  async addDiscountCode(): Promise<Cart> {
+    if (true) {
+      throw new Error("Error adding discount code");
+    }
+  },
+
+  async removeDiscountcode(): Promise<Cart> {
+    if (true) {
+      throw new Error("Error removing discount code");
+    }
+  },
+
+  async updateLineDeliveryMode(
+    input: cartSchema.UpdateCartLineDeliveryModeInput,
+  ): Promise<Cart> {
+    const e4Api = await getGraphqlClient();
+
+    const { data, errors } = await e4Api.e4ShippingMethodUpdateMD({
+      shippingId:
+        (input.cartLineDeliverySpecification[0] as LineDeliverySpecification)
+          .DeliverySpecification?.DeliveryModeId ?? "",
+    });
+
+    if (errors) {
+      throw new Error(
+        "Error setting order shipping method in updateLineDeliveryMode",
+      );
+    }
+
+    return translator.cartTransformValidate(
+      data?.setOrderShipping?.cart as E4Cart,
+    );
+  },
+
+  async removeLineDeliveryMode(): Promise<Cart> {
+    if (true) {
+      throw new Error("Error updating cart line delivery mode");
+    }
+  },
+
+  async getCardAcceptPoint(): Promise<CardPaymentAcceptPoint> {
+    if (true) {
+      throw new Error("Error getCardAcceptPoint");
+    }
+  },
+
+  async retrieveCardPaymentAcceptResult(): Promise<CardPaymentAcceptResult> {
+    if (true) {
+      throw new Error("Error retrieveCardPaymentAcceptResult");
+    }
+  },
+
+  async checkout(): Promise<SalesOrder> {
+    const e4Api = await getGraphqlClient();
+
+    // dummy payment
+    const generateToken = (length = 32) => {
+      const chars =
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+      let token = "";
+      for (let i = 0; i < length; i++) {
+        token += chars[Math.floor(Math.random() * chars.length)];
+      }
+      return token;
+    };
+
+    const { data, errors } = await e4Api.e4CartCheckoutSubmit({
+      input: {
+        paymentToken: generateToken(),
+      },
+    });
+
+    if (errors) {
+      throw new Error("Error submitting order");
+    }
+
+    return {
+      Id: data?.completeCart?.order?.id ?? "",
+      SalesLines: [],
+    };
+  },
+};
+
+export { cart };

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

@@ -0,0 +1,43 @@
+import {
+  SalesOrderInput,
+  GetSalesOrderDetailsInput,
+  SalesOrder,
+} from "@/api-manager/schemas/order.schema";
+import getGraphqlClient from "../../lib/get-graphql-client";
+import { orderDetailsMap, orderMap } from "./e4.remaps";
+import { merge } from "object-mapper";
+import { OrderApi } from "../../types/Datasource";
+
+const order: OrderApi = {
+  async getSalesOrders(input: SalesOrderInput): Promise<SalesOrder[]> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.e4OrderListSM({ id: input?.id });
+
+    if (errors) {
+      throw new Error("Error getting orders");
+    }
+
+    const orders = data?.getOrdersByUserId?.nodes || [];
+    return orders.map((order) => {
+      return merge(order, orderMap) as SalesOrder;
+    });
+  },
+  async getSalesOrderDetails(
+    input: GetSalesOrderDetailsInput,
+  ): Promise<SalesOrder> {
+    const e4Api = await getGraphqlClient(true);
+
+    const { data, errors } = await e4Api.e4OrderReadMD({
+      id: input?.transactionId,
+    });
+
+    if (errors) {
+      throw new Error("Error getting order details");
+    }
+
+    return merge(data?.getOrderById ?? {}, orderDetailsMap) as SalesOrder;
+  },
+};
+
+export default order;

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

@@ -0,0 +1,19 @@
+/* eslint-disable */
+import { OrganizationApi } from "../../types/Datasource";
+import { ChannelConfiguration } from "@/api-manager/schemas/organization.schema";
+
+// Todo: implement these stubs
+
+const organization: OrganizationApi = {
+  getChannelConfiguration: async (): Promise<ChannelConfiguration> => {
+    // @ts-ignore: Stub implementation, to be implemented later
+    return {};
+  },
+  // @ts-ignore: Stub implementation, to be implemented later
+  getStoresList(input) {
+    console.log(input);
+    return [];
+  },
+};
+
+export default organization;