@evenicanpm/storefront-core 1.0.0-alpha

package/src/api-manager/datasources/d365/d365-categories.datasource.ts

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { CategoryApi } from "../../types/Datasource";
+import {
+  CategoryHierarchy,
+  mapCategoryToHierarchy,
+} from "@/lib/category-helpers";
+import { getCategoriesAsync } from "@msdyn365-commerce/retail-proxy/dist/DataActions/CategoriesDataActions.g";
+import { D365DatasourceBase } from "./d365-base.datasource";
+
+class D365CategoriesDatasource
+  extends D365DatasourceBase
+  implements CategoryApi
+{
+  async getCategories(): Promise<CategoryHierarchy[]> {
+    const context = this.context;
+    try {
+      const categories = await getCategoriesAsync(
+        context as any,
+        context.requestContext.apiSettings.channelId,
+        0,
+      );
+      return (
+        mapCategoryToHierarchy(
+          categories,
+          context.requestContext.locale,
+          false,
+        ) || []
+      );
+    } catch (error) {
+      console.error(
+        "Error fetching categories:",
+        JSON.stringify(error, null, 2),
+      );
+      throw error;
+    }
+  }
+}
+
+export default D365CategoriesDatasource;

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

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { OrderApi } from "../../types/Datasource";
+import {
+  SalesOrder as DynSalesOrder,
+  SearchLocation,
+  ICallerContext,
+} from "@msdyn365-commerce/retail-proxy";
+import { getSalesOrderDetailsByTransactionIdAsync } from "@msdyn365-commerce/retail-proxy/dist/DataActions/SalesOrdersDataActions.g";
+import {
+  GetSalesOrderDetailsInput,
+  SalesOrder,
+} from "@/api-manager/schemas/order.schema";
+import { D365ProductDatasource } from "./d365-product.datasource";
+import uniq from "lodash/uniq";
+import { D365DatasourceBase } from "./d365-base.datasource";
+class D365OrderDatasource extends D365DatasourceBase implements OrderApi {
+  getSalesOrders(): Promise<any> {
+    throw new Error("Method not implemented.");
+  }
+  async getSalesOrderDetails(
+    input: GetSalesOrderDetailsInput,
+  ): Promise<SalesOrder> {
+    const context = this.context;
+    const { transactionId } = input;
+    try {
+      const data = await getSalesOrderDetailsByTransactionIdAsync(
+        context as any,
+        transactionId,
+        SearchLocation.All,
+      );
+      const mergedData = await mergeOrderWithProducts(data, this.context);
+      return mergedData;
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+}
+
+const mergeOrderWithProducts = async (
+  salesOrder: DynSalesOrder,
+  context: ICallerContext,
+): Promise<SalesOrder> => {
+  const _salesOrder = { ...salesOrder } as SalesOrder;
+  if (_salesOrder.SalesLines?.length) {
+    //Get products
+    const productIds = _salesOrder.SalesLines.map(
+      (line) => line.ProductId,
+    ).filter((p) => p !== undefined);
+    if (productIds.length) {
+      const productDataSource = new D365ProductDatasource(context);
+      const products = await productDataSource.getProductByIds({
+        id: uniq(productIds),
+      });
+      if (products) {
+        _salesOrder.SalesLines.forEach((line) => {
+          const product = products.find((p) => p.RecordId === line.ProductId);
+          if (product) {
+            line.Product = product;
+          }
+        });
+      }
+    }
+  }
+  return _salesOrder;
+};
+
+export default D365OrderDatasource;

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

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { OrganizationApi } from "../../types/Datasource";
+import {
+  getChannelDeliveryOptionsAsync,
+  getOrgUnitConfigurationAsync,
+  getStoreHoursAsync,
+} from "@msdyn365-commerce/retail-proxy/dist/DataActions/OrgUnitsDataActions.g";
+import {
+  ChannelConfiguration,
+  GetOrgUnitLocationsByAreaInput,
+  OrgUnitLocation,
+  OrgUnitLocationReturnType,
+} from "@/api-manager/schemas/organization.schema";
+import { getOrgUnitLocationsByAreaAsync } from "@msdyn365-commerce/retail-proxy/dist/DataActions/OrgUnitsDataActions.g";
+import {
+  ChannelDeliveryOption,
+  ICallerContext,
+} from "@msdyn365-commerce/retail-proxy";
+import { D365DatasourceBase } from "./d365-base.datasource";
+
+class D365OrganizationDatasource
+  extends D365DatasourceBase
+  implements OrganizationApi
+{
+  async getStoresList(
+    input: GetOrgUnitLocationsByAreaInput,
+  ): Promise<OrgUnitLocationReturnType[]> {
+    const context = this.context;
+    const { queryResultSettings, searchArea, deliveryModeTypeFilter } = input;
+    const ctx = { ...context } as any;
+    ctx.queryResultSettings = queryResultSettings;
+    const locations = await getOrgUnitLocationsByAreaAsync(
+      ctx as any,
+      searchArea,
+      deliveryModeTypeFilter,
+    );
+    const channelList = locations
+      .map((location) => location.ChannelId)
+      .filter((id) => id !== undefined);
+    const locationPickupList = await this.getChannelDeliveryOptions(
+      context,
+      channelList,
+    );
+
+    const locationHoursPromiseList = locations.map((location) => {
+      const locationDeliveryOption = locationPickupList?.find(
+        (channelDeliveryOption) =>
+          channelDeliveryOption.ChannelId === location.ChannelId,
+      );
+      return this.getStoreHours(location, locationDeliveryOption, context);
+    });
+    const locationHours = await Promise.all(locationHoursPromiseList);
+    return locationHours;
+  }
+
+  async getChannelConfiguration(): Promise<ChannelConfiguration> {
+    const context = this.context;
+    return getOrgUnitConfigurationAsync(context as any);
+  }
+
+  async getStoreHours(
+    store: OrgUnitLocation,
+    channelDeliveryOption: ChannelDeliveryOption | undefined,
+    context: ICallerContext,
+  ): Promise<OrgUnitLocationReturnType> {
+    const storeHours = await getStoreHoursAsync(
+      context as any,
+      store.OrgUnitNumber,
+    );
+    return {
+      location: store,
+      storeHours: storeHours,
+      pickupOptions: channelDeliveryOption?.DeliveryOptions,
+    };
+  }
+
+  async getChannelDeliveryOptions(
+    context: ICallerContext,
+    channelList: number[],
+  ): Promise<ChannelDeliveryOption[] | undefined> {
+    const DELIVERY_OPTION_TYPE = 4; //This is to get all pickup modes, not sure where the number comes from.
+    const channelDeliveryOptions = await getChannelDeliveryOptionsAsync(
+      context as any,
+      channelList,
+      DELIVERY_OPTION_TYPE,
+    );
+    return channelDeliveryOptions;
+  }
+}
+
+export default D365OrganizationDatasource;

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

@@ -0,0 +1,272 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { ProductApi } from "../../types/Datasource";
+import {
+  InventoryAvailabilitySearchCriteria,
+  IQueryResultSettings,
+  ProductRefinerSource,
+  ProductSearchCriteria,
+  ProductSearchResult,
+  SimpleProduct,
+} from "@msdyn365-commerce/retail-proxy";
+import {
+  getByIdAsync,
+  getByIdsAsync,
+  searchByCriteriaAsync,
+  getRelatedProductsAsync,
+  getDimensionValuesWithEstimatedAvailabilitiesAsync,
+  getAttributeValuesAsync,
+  getProductSearchRefinersAsync,
+  getEstimatedAvailabilityAsync,
+} from "@msdyn365-commerce/retail-proxy/dist/DataActions/ProductsDataActions.g";
+import {
+  GetProductByIdInput,
+  GetProductByIdsInput,
+  GetRelatedProductsInput,
+  SearchByCriteriaInput,
+  SearchByCriteriaResponse,
+  searchProductsInput,
+} from "@/api-manager/schemas/product.schema";
+import { createDimSearchCriteria } from "./utils/create-search-criteria";
+import {
+  testMedia,
+  validateAndSetMediaUrls,
+} from "./utils/product-images-utils";
+import D365CategoriesDatasource from "./d365-categories.datasource";
+import { InventorySearchCriteriaInput } from "@/api-manager/schemas/product.schema";
+
+import { D365DatasourceBase } from "./d365-base.datasource";
+
+const setFullProductImgUrl = async (
+  product: SimpleProduct | ProductSearchResult,
+  baseImgUrl: string,
+) => {
+  let imgUrl = `${baseImgUrl}${product.PrimaryImageUrl}`;
+  const isValidImg = (await testMedia([imgUrl])).length > 0;
+  if (isValidImg) {
+    product.PrimaryImageUrl = imgUrl;
+  } else {
+    imgUrl = `${baseImgUrl}Products/${product.ItemId}_000_001.png`;
+  }
+  product.PrimaryImageUrl = imgUrl;
+};
+
+// const getProductRefinersByCollection = async (context: ICallerContext, categoryId: number) => {
+//     const searchCriteria = getSearchCriteriaFromInput(context, categoryId);
+//     const ctx: any = { ...context };
+//     try {
+//         const refiners = await getProductSearchRefinersAsync(ctx, searchCriteria);
+//         if (!refiners) {
+//             console.warn('getProductSearchRefinersAsync returned no refiners');
+//             return [];
+//         }
+//         return refiners as any[];
+//     } catch (error) {
+//         console.warn('Failed to fetch refiners, returning empty array:', error);
+//         return [];
+//     }
+// };
+
+class D365ProductDatasource extends D365DatasourceBase implements ProductApi {
+  /**
+   * Gets product by id, sets full image url and dimension values
+   * @params input GetProductByIdInput
+   * @returns simple product with full image url and dimension values under property DimensionValues
+   */
+  async getProductById(input: GetProductByIdInput) {
+    const context = this.context;
+    const channelId = context.requestContext.apiSettings.channelId;
+
+    const product = await getByIdAsync(
+      context as any,
+      Number(input.id),
+      channelId,
+    );
+
+    const images = await validateAndSetMediaUrls(
+      product,
+      context.requestContext.apiSettings.baseImageUrl,
+    );
+    //setFullProductImgUrl(product, context.requestContext.apiSettings.baseImageUrl);
+
+    const dimensionPromises =
+      product?.Dimensions?.map(async ({ DimensionTypeValue }) => {
+        return getDimensionValuesWithEstimatedAvailabilitiesAsync(
+          context as any,
+          product?.RecordId,
+          createDimSearchCriteria(DimensionTypeValue),
+        );
+      }) || [];
+
+    const attributesPromise = getAttributeValuesAsync(
+      context as any,
+      product?.RecordId,
+      channelId,
+      0,
+    );
+
+    const dimensionsValues = await Promise.all(dimensionPromises);
+    const attributes = await attributesPromise;
+
+    return {
+      ...product,
+      DimensionValues: dimensionsValues,
+      Attributes: attributes,
+      PrimaryImageUrl: images?.[0],
+      Images: images || [],
+    };
+  }
+
+  async getProductByIds(input: GetProductByIdsInput) {
+    const context = this.context;
+    const products = await getByIdsAsync(
+      context as any,
+      context.requestContext.apiSettings.channelId,
+      input?.id.map(Number),
+    );
+    const promises = [];
+    for (const product of products) {
+      promises.push(
+        setFullProductImgUrl(
+          product,
+          context.requestContext.apiSettings.baseImageUrl,
+        ),
+      );
+    }
+    await Promise.all(promises);
+    return products;
+  }
+
+  async getProductsList(
+    input: SearchByCriteriaInput,
+  ): Promise<SearchByCriteriaResponse> {
+    const context = this.context;
+    const {
+      searchState: { queryResultSettings, refinement, searchTerm },
+      categoryId,
+    } = input;
+
+    const searchCriteria: ProductSearchCriteria = {
+      Context: {
+        CatalogId: context.requestContext.apiSettings.catalogId || 0,
+        ChannelId: context.requestContext.apiSettings.channelId,
+      },
+    };
+
+    if (searchCriteria) searchCriteria.SearchCondition = searchTerm;
+
+    if (refinement) searchCriteria.Refinement = refinement;
+
+    if (categoryId) {
+      searchCriteria.CategoryIds = [categoryId];
+    }
+
+    const refinerSearchSettings = { ...searchCriteria };
+
+    //Remove the price refiner from the refinement to stop the price adjustment
+    refinerSearchSettings.Refinement = refinerSearchSettings.Refinement?.filter(
+      (r) => r.RefinerSourceValue !== ProductRefinerSource.Price,
+    );
+
+    const ctx = { ...context } as any;
+    ctx.queryResultSettings = queryResultSettings;
+    const productSearchPromise = searchByCriteriaAsync(ctx, searchCriteria);
+    const refinersPRomise = getProductSearchRefinersAsync(
+      ctx,
+      refinerSearchSettings,
+    );
+    const [productResults, refinerResults] = await Promise.all([
+      productSearchPromise,
+      refinersPRomise,
+    ]);
+    const count = productSearchPromise.metadata?.count || 500; //Set to high number for pagination
+    const promises = [];
+    for (const product of productResults) {
+      promises.push(
+        setFullProductImgUrl(
+          product,
+          context.requestContext.apiSettings.baseImageUrl,
+        ),
+      );
+    }
+    await Promise.all(promises);
+    return {
+      products: productResults,
+      refiners: refinerResults,
+      count,
+    };
+  }
+
+  async searchProducts(input: searchProductsInput) {
+    const context = this.context;
+    const ctx = { ...context } as any;
+    const queryResultSettings: IQueryResultSettings = {
+      Paging: {
+        Skip: 0,
+        Top: 10,
+      },
+      count: true,
+    };
+    ctx.queryResultSettings = queryResultSettings;
+    const searchCriteria: ProductSearchCriteria = {
+      Context: {
+        CatalogId: 0,
+        ChannelId: context.requestContext.apiSettings.channelId,
+      },
+      SearchCondition: input.searchText,
+    };
+    if (input.category && input.category !== 0) {
+      searchCriteria.CategoryIds = [input.category];
+    }
+    if (input.itemIds?.length) {
+      searchCriteria.ItemIds = input.itemIds.map((id) => ({
+        ItemId: id,
+      }));
+    }
+    const results = await searchByCriteriaAsync(ctx as any, searchCriteria);
+    const parsed = JSON.parse(JSON.stringify(results));
+    return parsed;
+  }
+
+  async getCategoryList(): Promise<any> {
+    // TODO ? Why is the get category list here and calling the category data source. Can we decide if we want to have a separate one for categories or remove this?
+    // agree with above statement - sam
+    const categoriesDatasource = new D365CategoriesDatasource(this.context);
+    const categories = await categoriesDatasource.getCategories();
+    return { categories: { category: categories } };
+  }
+
+  async getRelatedProducts(input: GetRelatedProductsInput) {
+    const context = this.context;
+    return getRelatedProductsAsync(
+      context as any,
+      context.requestContext.apiSettings.channelId,
+      input.id,
+      0,
+      1,
+    );
+  }
+
+  async getInventory(input: InventorySearchCriteriaInput) {
+    const context = this.context;
+    try {
+      const searchCriteria: InventoryAvailabilitySearchCriteria = {
+        ProductIds: input.searchCriteria.productIds,
+        QuantityUnitTypeValue: 2, // Sales Type
+        DefaultWarehouseOnly: input.searchCriteria.defaultWarehouseOnly,
+        SearchArea: input.searchCriteria.searchArea,
+        FilterByChannelFulfillmentGroup: true,
+      };
+      const data = await getEstimatedAvailabilityAsync(
+        context as any,
+        searchCriteria,
+      );
+      return data;
+    } catch (error) {
+      console.error("Error getting inventory:", error);
+      throw error;
+    }
+  }
+}
+
+export { D365ProductDatasource };

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

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { SessionApi } from "../../types/Datasource";
+//import { Customer, ICallerContext } from "@msdyn365-commerce/retail-proxy";
+//import { readAsync } from "@msdyn365-commerce/retail-proxy/dist/DataActions/CustomersDataActions.g";
+import { Session } from "@/api-manager/schemas/session.schema";
+//import { getContextFromCookie } from "./utils/get-context-cookie";
+import { D365DatasourceBase } from "./d365-base.datasource";
+
+class D365SessionDatasource extends D365DatasourceBase implements SessionApi {
+  async sessionInit(): Promise<Session> {
+    console.warn("sessionInit not implemented");
+    return Promise.resolve({} as Session);
+  }
+  async sessionLogout(): Promise<boolean> {
+    return true;
+  }
+  getSession(): Promise<Session> {
+    //throw new Error("Method not implemented");
+    console.warn("getSession not implemented on d365");
+    return Promise.resolve({} as Session);
+  }
+}
+
+export default D365SessionDatasource;

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

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { UserApi } from "@/api-manager/types/Datasource";
+import { User, UserCounts } from "@/schemas/user.schema";
+import {
+  Customer,
+  CommerceProperty,
+  ICallerContext,
+} from "@msdyn365-commerce/retail-proxy";
+import {
+  createCustomerAsync,
+  readAsync,
+  updateAsync,
+} from "@msdyn365-commerce/retail-proxy/dist/DataActions/CustomersDataActions.g";
+import jwt from "jsonwebtoken";
+import { WishList } from "../e4/graphqlRequestSdk";
+import { D365DatasourceBase } from "./d365-base.datasource";
+
+class D365UserDatasource extends D365DatasourceBase implements UserApi {
+  getUserCounts(): Promise<UserCounts> {
+    throw new Error("Method not implemented.");
+  }
+  getWishlists(): Promise<WishList[]> {
+    throw new Error("Method not implemented.");
+  }
+  getWishlistDetails(): Promise<WishList> {
+    throw new Error("Method not implemented.");
+  }
+  createWishlist(): Promise<WishList> {
+    throw new Error("Method not implemented.");
+  }
+  deleteWishlist(): Promise<string> {
+    throw new Error("Method not implemented.");
+  }
+
+  async updateUser(user: User): Promise<User> {
+    const context = this.context;
+    const existing: Customer = await readAsync(context as any, "");
+    existing.Addresses ??= [];
+    existing.Addresses = existing.Addresses.map((addr) => ({
+      ...addr,
+      IsPrimary: addr.RecordId?.toString() === user.DefaultShippingAddressId,
+    }));
+    const propKey = "DefaultShippingAddressId";
+    existing.ExtensionProperties = existing.ExtensionProperties ?? [];
+    existing.ExtensionProperties = existing.ExtensionProperties.filter(
+      (p: CommerceProperty) => p.Key !== propKey,
+    );
+    existing.ExtensionProperties.push({
+      Key: propKey,
+      Value: { StringValue: user.DefaultShippingAddressId } as any,
+    });
+    const updated: Customer = await updateAsync(
+      context as any,
+      existing as any,
+    );
+    const mappedAddresses = (updated.Addresses ?? []).map((a) => ({
+      ...a,
+      Id: a.RecordId?.toString() ?? "",
+    }));
+    return {
+      ...updated,
+      Addresses: mappedAddresses,
+    } as User;
+  }
+
+  async getUser(): Promise<User | null> {
+    const context = this.context;
+    if (!context.requestContext.user.isAuthenticated) return null;
+
+    let customer: Customer | null;
+    try {
+      customer = await readAsync(context as any, "");
+    } catch (error) {
+      //For now, we assume this error means the user does not exist
+      //So we create a new user
+      console.warn(JSON.stringify(error));
+      const token = jwt.decode(context.requestContext.user.token) as TokenData;
+      customer = await createUser(context as any, token);
+      return customer;
+    }
+    const mappedAddresses = (customer.Addresses ?? []).map((a) => ({
+      ...a,
+      Id: a.RecordId?.toString() ?? "",
+    }));
+    return {
+      ...customer,
+      Addresses: mappedAddresses,
+    } as User;
+  }
+}
+
+const createUser = async (context: ICallerContext, token: TokenData) => {
+  const firstName = token.given_name;
+  let lastName = token.family_name;
+  let email;
+  if (token.emails && Array.isArray(token.emails)) {
+    email = token.emails[0];
+  } else if (token.hasOwnProperty("email")) {
+    email = token.email;
+  }
+  if (!lastName) {
+    lastName = ".";
+  }
+  const userPromise = createCustomerAsync(context as any, {
+    AccountNumber: "",
+    Email: email,
+    FirstName: firstName,
+    LastName: lastName,
+  });
+  const user = await userPromise;
+  return user;
+};
+export default D365UserDatasource;
+
+type TokenData = {
+  aud: string;
+  iss: string;
+  exp: number;
+  nbf: number;
+  oid: string;
+  sub: string;
+  emails: string[];
+  email?: string;
+  newUser: boolean;
+  given_name: string;
+  family_name: string;
+  tfp: string;
+  scp: string;
+  azp: string;
+  ver: string;
+  iat: number;
+};

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

@@ -0,0 +1,45 @@
+import {
+  AddressApi,
+  CategoryApi,
+  Datasource,
+  OrderApi,
+  OrganizationApi,
+  PrimaryDatasource,
+  ProductApi,
+  SessionApi,
+  UserApi,
+} from "../../types/Datasource";
+import { D365ProductDatasource } from ".";
+import { D365CartDatasource } from "./d365-cart.datasource";
+import D365AddressDatasource from "./d365-address.datasource";
+import D365CategoriesDatasource from "./d365-categories.datasource";
+import D365OrganizationDatasource from "./d365-organization.datasource";
+import D365OrderDatasource from "./d365-order.datasource";
+import D365SessionDatasource from "./d365-session.datasource";
+import D365UserDatasource from "./d365-user.datasource";
+import { ICallerContext } from "@msdyn365-commerce/retail-proxy";
+
+export class D365Datasource extends Datasource implements PrimaryDatasource {
+  user: UserApi;
+  product: ProductApi;
+  categories: CategoryApi;
+  order: OrderApi;
+  address: AddressApi;
+  organization: OrganizationApi;
+  session: SessionApi;
+  cart: D365CartDatasource;
+  constructor(name: string, context: ICallerContext) {
+    super(name);
+    this.cart = new D365CartDatasource(context);
+    this.categories = new D365CategoriesDatasource(context);
+    this.order = new D365OrderDatasource(context);
+    this.address = new D365AddressDatasource(context);
+    this.product = new D365ProductDatasource(context);
+    this.organization = new D365OrganizationDatasource(context);
+    this.session = new D365SessionDatasource(context);
+    this.user = new D365UserDatasource(context);
+  }
+  // Datasources
+}
+
+// export default d365Datasource;

package/src/api-manager/datasources/d365/index.ts

@@ -0,0 +1,4 @@
+import { D365ProductDatasource } from "./d365-product.datasource";
+import { D365Datasource } from "./d365.datasource";
+
+export { D365ProductDatasource, D365Datasource };